Binary Search Trees

# Binary Search Trees

Télécharger la présentation

## Binary Search Trees

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Binary Search Trees

2. Binary Search Tree (BST) A binary search tree (BST) is a binary tree which has the following properties: • Each node has a value. • An order is defined on these values. • The left subtree of a node contains only values less than or equal to the node's value. • The right subtree of a node contains only values greater than or equal to the node's value. 7 3 11 1 5 9 13

3. Binary Search Tree (BST) The major advantage of binary search trees is that the related sorting algorithms and search algorithms such as in-order traversal can be very efficient.

4. Searching a BST Searching a binary tree for a specific value is a process that can be performed recursively because of the order in which values are stored. We begin by examining the root. If the value we are searching for equals the root, the value exists in the tree. If it is less than the root, then it must be in the left subtree, so we recursively search the left subtree in the same manner. Similarly, if it is greater than the root, then it must be in the right subtree, so we recursively search the right subtree. If we reach a leaf and have not found the value, then the item is not where it would be if it were present, so it does not lie in the tree at all.

5. Searching in a BST Write an algorithm in pseudocode that searches a BST for the key value 9 Algorithm TreeSearchFor9( &Root ) if Root is external then 9 isn’t here - return false if Root contains 9 then we found it – return true else if 9 < Root.element() then Search(leftSubtree) else Search(rightSubtree) 7 3 11 1 5 9 13

6. TreeSearch Algorithm Algorithm TreeSearch( target, &v ) IN: target = key to search for v = node to start the search OUT: Node w that is either the target or an external node where the target should go if v is external node then return v if v.element() == target then return v else if target < v.element() then return TreeSearch( target, leftChild(v) ) else return TreeSearch( target, rightChild(v) )

7. Key This is the part of information used to order the elements in a binary search tree. • Must be able to put it in an order or rank – i.e., we must be able to compare two keys and determine whether one is larger than the other • Can be externally generated and assigned • Examples: • Student ID – used to identify students • Social security number – used to identify workers in the U.S. • Account ID – used to identify an account holder • ISBN – used to identify a book • Call number – used to identify a library resource

8. BST Stores Keys • The data itself can be its own key D These letters are data that we can put into an order based on their ASCII code. B F A C E G • The keys may represent other data 6274 These are account numbers that can be ordered, and they represent records containing additional data. 2843 8837 1892 4892 9523

9. left parent right item Item • Class that contains a key and the element associated with the key • Objects of this class are stored in the nodes of a BST • We search for the value in the key field • When we find the key, then we get the element, too BST Node

10. Item Class template<typename Key, typename Element> class Item { private: //Every Item object has two data members Key _key; Element _elem; public: Item( const Key& k = Key(), const Element& e = Element()) : _key(k), _elem(e) { } const Key& key() const { return _key; } Element& element() { return _elem; } //... };

11. BinarySearchTree Class • Public Operations int size() bool isEmpty() pos find( key ) void insertItem( key, element ) void removeElement( key ) • Data Member LinkedBinaryTree<BSTItem> T;

12. TreeSearch Implementationby finder() – called by find() //Algorithm TreeSearch( target, v ) // if v is external node then return v // if v.element() == target then return v // else if target < v.element() then // return TreeSearch( target, leftChild(v) ) // else // return TreeSearch( target, rightChild(v) ) BTPosition finder( const Key& k, const BTPosition& p ) { if( T.isExternal(p) ) return p; // k wasn’t found Key curKey = key(p); //Get the key of node p if( k < curKey ) return finder( k, T.leftChild(p) ); else if( k > curKey ) return finder( k, T.rightChild(p) ); else return p; // k == curKey, so we found it }

13. Using the Position Object • The BinarySearchTree defines its own Position class so that it will be able to hold an Item object – p. 421 • Its methods make it easy for us to get the element or the key • Example: int recNum = p.element();

14. Position typedef typename LinkedBinaryTree<BSTItem>::Position BTPosition; class Position { private: BTPosition btPos; public: Position(const BTPosition &p = NULL) : btPos(p) { } Element& element() // get element { return btPos.element().element(); } const Key& key() const // get key { return btPos.element().key(); } bool isNull() const // a null position? { return btPos.isNull(); } };

15. Inserting into a BST Insertion begins as a search would begin; if the root is not equal to the value, we search the left or right subtrees as before. Eventually, we will reach an external node and add the value as its right or left child, depending on the node's value. In other words, we examine the root and recursively insert the new node to the left subtree if the new value is less than or equal the root, or the right subtree if the new value is greater than the root.

16. Inserting:Key = 4892, Element = 2 6274 0 2843 1 8837 3

17. Inserting:Key = 4892, Element = 2 • Find the position of an external node where the key should be inserted p = index.finder( 4892, T.root() ); 6274 0 2843 1 8837 3

18. Inserting:Key = 4892, Element = 2 • Find an external node where the key should be inserted • Expand the node T.expandExternal(p); 6274 0 2843 1 8837 3

19. Inserting:Key = 4892, Element = 2 • Find an external node where the key should be inserted • Expand the node • Add the key and element at the node 6274 0 2843 1 8837 3 4892 2

20. Deleting from a BST There are several cases to be considered: • Deleting a leaf: Deleting a node with no children is easy, as we can simply remove it from the tree. • Deleting a node with one child: Delete it and replace it with its child. • Deleting a node with two children: Suppose the node to be deleted is called N. We replace the value of N with either its in-order successor (the left-most child of the right subtree) or the in-order predecessor (the right-most child of the left subtree).

21. Deleting a node with one child(Key = 4892) • Find the position of the node that contains the key 6274 0 2843 1 8837 3 r 1892 4 4892 2 9523 5 3165 6

22. Deleting a node with one child(Key = 4892) • Find the position of the node that contains the key • If one of the node’s children is external remove the node and replace it with the sibling of its external child 6274 0 2843 1 8837 3 r 1892 4 4892 2 9523 5 p 3165 6

23. Deleting a node with one child(Key = 4892) • Find the position of the node that contains the key • If one of the node’s children is external remove the node and replace it with the sibling of its external child 6274 0 2843 1 8837 3 1892 4 3165 6 9523 5

24. Deleting a node with two children(Key = 2843) • Find the position of the node that contains the key, call it r 6274 0 r 2843 1 8837 3 1892 4 4892 2 9523 5 3165 6

25. Deleting a node with two children(Key = 2843) • Find the position of the node that contains the key, call it r • If both of r’s children are internal: • Find the left-most node in r’s right subtree, call it p • Move the contents of p’s parent into r • Remove p and p’s parent 6274 0 r 2843 1 8837 3 1892 4 4892 2 9523 5 3165 6 p

26. Deleting a node with two children(Key = 2843) • Find the position of the node that contains the key, call it r • If both of r’s children are internal: • Find the left-most node in r’s right subtree, call it p • Move the contents of p’s parent into r • Remove p and p’s parent 6274 0 r 3165 6 8837 3 1892 4 4892 2 9523 5 3165 6 p

27. Deleting a node with two children(Key = 2843) • Find the position of the node that contains the key, call it r • If both of r’s children are internal: • Find the left-most node in r’s right subtree, call it p • Move the contents of p’s parent into r • Remove p and p’s parent 6274 0 r 3165 6 8837 3 1892 4 4892 2 9523 5

28. Removing Implemented by remover() – called by removeElement() BTPosition remover( const BTPosition& r ){ //r was located with finder() BTPosition p; if( T.isExternal( T.leftChild(r) )) p = T.leftChild(r); else if( T.isExternal( T.rightChild(r) )) p = T.rightChild(r); else { p = T.rightChild(r); do { p = T.leftChild(p) } while( T.isInternal(p) ); setItem( r, T.parent(p).element() ); } return T.removeAboveExternal(p); }