1 / 47

Nell Dale Chapter 8 Binary Search Trees

C++ Plus Data Structures. Nell Dale Chapter 8 Binary Search Trees Slides by Sylvia Sorkin, Community College of Baltimore County - Essex Campus. Jake’s Pizza Shop. Owner Jake Manager Chef Brad Carol

moses
Télécharger la présentation

Nell Dale Chapter 8 Binary Search Trees

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. C++ Plus Data Structures Nell Dale Chapter 8 Binary Search Trees Slides by Sylvia Sorkin, Community College of Baltimore County - Essex Campus

  2. Jake’s Pizza Shop Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len

  3. A Tree Has a Root Node ROOT NODE Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len

  4. Leaf nodes have no children LEAF NODES Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len

  5. A Tree Has Levels Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEVEL 0

  6. Level One LEVEL 1 Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len

  7. Level Two Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEVEL 2

  8. A Subtree Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEFT SUBTREE OF ROOT NODE

  9. Another Subtree Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len RIGHT SUBTREE OF ROOT NODE

  10. Binary Tree A binary tree is a structure in which: Each node can have at most two children, and in which a unique path exists from the root to every other node. The two children of a node are called the left child and the right child, if they exist.

  11. A Binary Tree V Q L T A E K S

  12. How many leaf nodes? V Q L T A E K S

  13. How many descendants of Q? V Q L T A E K S

  14. V Q L T A E K S How many ancestors of K?

  15. Implementing a Binary Tree with Pointers and Dynamic Data V Q L T A E K S

  16. Each node contains two pointers template< class ItemType > struct TreeNode { ItemType info;// Data member TreeNode<ItemType>* left;// Pointer to left child TreeNode<ItemType>* right; // Pointer to right child }; NULL ‘A’6000 .left .info .right

  17. // BINARY SEARCH TREE SPECIFICATION template< class ItemType > class TreeType { public: TreeType ( ); // constructor ~TreeType ( ); // destructor bool IsEmpty ( ) const; bool IsFull ( ) const; int NumberOfNodes ( ) const; void InsertItem ( ItemType item ); void DeleteItem (ItemType item ); void RetrieveItem ( ItemType& item, bool& found ); void PrintTree (ofstream& outFile) const; . . . private: TreeNode<ItemType>* root; }; 17

  18. ‘J’ TreeType ~TreeType ‘S’ ‘E’ IsEmpty InsertItem ‘H’ ‘A’ TreeType<char> CharBST; Private data: root RetrieveItem PrintTree . . .

  19. A Binary Search Tree (BST) is . . . A special kind of binary tree in which: 1. Each node contains a distinct data value, 2. The key values in the tree can be compared using “greater than” and “less than”, and 3. The key value of each node in the tree is less than every key value in its right subtree, and greater than every key value in its left subtree.

  20. ‘J’ Shape of a binary search tree . . . Depends on its key values and their order of insertion. Insert the elements ‘J’ ‘E’ ‘F’ ‘T’ ‘A’ in that order. The first value to be inserted is put into the root node.

  21. ‘J’ ‘E’ Inserting ‘E’ into the BST Thereafter, each value to be inserted begins by comparing itself to the value in the root node, moving left it is less, or moving right if it is greater. This continues at each level until it can be inserted as a new leaf.

  22. ‘J’ ‘E’ ‘F’ Inserting ‘F’ into the BST Begin by comparing ‘F’ to the value in the root node, moving left it is less, or moving right if it is greater. This continues until it can be inserted as a leaf.

  23. ‘J’ ‘T’ ‘E’ ‘F’ Inserting ‘T’ into the BST Begin by comparing ‘T’ to the value in the root node, moving left it is less, or moving right if it is greater. This continues until it can be inserted as a leaf.

  24. ‘J’ ‘T’ ‘E’ ‘A’ ‘F’ Inserting ‘A’ into the BST Begin by comparing ‘A’ to the value in the root node, moving left it is less, or moving right if it is greater. This continues until it can be inserted as a leaf.

  25. ‘A’ What binary search tree . . . is obtained by inserting the elements ‘A’ ‘E’ ‘F’ ‘J’ ‘T’ in that order?

  26. ‘A’ ‘E’ ‘F’ ‘J’ ‘T’ Binary search tree . . . obtained by inserting the elements ‘A’ ‘E’ ‘F’ ‘J’ ‘T’ in that order.

  27. Exercise on Building a BST • Build a binary search tree from the following numbers. Use the first number as the root node and process the numbers from left to right. • [23,3,34,15,18,12,2,45,48,46,49,33]

  28. ‘J’ Another binary search tree ‘T’ ‘E’ ‘A’ ‘H’ ‘M’ ‘P’ ‘K’ Add nodes containing these values in this order: ‘D’ ‘B’ ‘L’ ‘Q’ ‘S’ ‘V’ ‘Z’

  29. ‘D’ ‘Z’ ‘K’ ‘B’ ‘L’ ‘Q’ ‘S’ Is ‘F’ in the binary search tree? ‘J’ ‘T’ ‘E’ ‘A’ ‘V’ ‘M’ ‘H’ ‘P’

  30. // BINARY SEARCH TREE SPECIFICATION class TreeType { public: TreeType ( ) ; // constructor ~TreeType ( ) ; // destructor bool IsEmpty ( ) const ; bool IsFull ( ) const ; int NumberOfNodes ( ) const ; void InsertItem ( int item ) ; void DeleteItem (int item ) ; void RetrieveItem ( int& item , bool& found ) ; void PrintTree (ofstream& outFile) const ; . . . private: TreeNode* root ; }; 30

  31. // SPECIFICATION (continued) // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - // RECURSIVE PARTNERS OF MEMBER FUNCTIONS WHY HELPERS? void PrintHelper ( TreeNode* ptr, ofstream& outFile ) ; void InsertHelper ( TreeNode* & ptr, int item ) ; void RetrieveHelper (TreeNode* ptr, int& item, bool& found ) ; void DestroyHelper ( TreeNode*& ptr ) ; 31

  32. // BINARY SEARCH TREE IMPLEMENTATION // OF MEMBER FUNCTIONS AND THEIR HELPER FUNCTIONS // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - TreeType :: TreeType ( ) // constructor { root = NULL ; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - bool TreeType :: IsEmpty( ) const { return ( root == NULL ) ; } 32

  33. void TreeType :: RetrieveItem ( int& item, bool& found ) { RetrieveHelper ( root, item, found ) ; } void RetrieveHelper ( TreeNode* ptr, int& item, bool& found) { if ( ptr == NULL ) found = false ; else if ( item < ptr->info ) // GO LEFT RetrieveHelper( ptr->left , item, found ) ; else if ( item > ptr->info ) // GO RIGHT RetrieveHelper( ptr->right , item, found ) ; else { item = ptr->info ; found = true ; } } 33

  34. void TreeType :: InsertItem ( int item ) { InsertHelper ( root, item ) ; } void InsertHelper ( TreeNode*& ptr, int item ) { if ( ptr == NULL ) { // INSERT item HERE AS LEAF ptr = new TreeNode ; ptr->right = NULL ; ptr->left = NULL ; ptr->info = item ; } else if ( item < ptr->info ) // GO LEFT InsertHelper( ptr->left , item ) ; else if ( item > ptr->info ) // GO RIGHT InsertHelper( ptr->right , item ) ; } 34

  35. ‘J’ Inorder Traversal: A E H J M T Y Print second tree ‘T’ ‘E’ ‘A’ ‘H’ ‘M’ ‘Y’ Print left subtree first Print right subtree last

  36. // INORDER TRAVERSAL void TreeType :: PrintTree ( ofstream& outFile ) const { PrintHelper ( root, outFile ) ; } void PrintHelper ( TreeNode* ptr, ofstream& outFile ) { if ( ptr != NULL ) { PrintHelper( ptr->left , outFile ) ; // Print left subtree outFile << ptr->info ; PrintHelper( ptr->right, outFile ) ; // Print right subtree } } 36

  37. ‘J’ Preorder Traversal: J E A H T M Y Print first tree ‘T’ ‘E’ ‘A’ ‘H’ ‘M’ ‘Y’ Print left subtree second Print right subtree last

  38. ‘J’ Postorder Traversal: A H E M Y T J Print last tree ‘T’ ‘E’ ‘A’ ‘H’ ‘M’ ‘Y’ Print left subtree first Print right subtree second

  39. TreeType:: ~TreeType ( ) // DESTRUCTOR { DestroyHelper ( root ) ; } void DestroyHelper ( TreeNode* ptr ) // Post: All nodes of the tree pointed to by ptr are deallocated. { if ( ptr != NULL ) { DestroyHelper ( ptr->left ) ; DestroyHelper ( ptr->right ) ; delete ptr ; } } 39

  40. Deleting Nodes from a BST • Deleting a node from a BST is not straightforward!! • We deal with three different cases, assuming we have already found the node • (A) Deleting a leaf node • (B) Deleting a node with one child • (C) Deleting a node with two children

  41. Deleting A Leaf Node • Deleting a leaf node is only two-step operation • -Find the node • -Set its parent’s appropriate pointer to NULL and delete the node

  42. Deleting A Node With One Child • Deleting a node with one child is somewhat tricky. We do not want to lose the descendents • We let the parent of the node being deleted skip over it and point to its child • Then the node is deleted

  43. Deleting A Node With Two Children • Deleting a node with two children is the most difficult task!!!! • Its parent cannot be made to point to the two children with only one pointer • Instead, we can “copy” a selected node to the node being deleted and get rid of the other node

  44. The “Selected” Node • The selected node is the node with highest value in the left subtree of the node to be deleted • This value will be found at the extreme right of the left subtree of the node to be deleted • For example, consider the diagram shown:

  45. Deleting A Node With Two Children • Thus we will retain the BST structure without violating any of its formation rules • Now we can start developing the delete function that can detect and deal with the cases shown

  46. Delete Function • We pass the pointer *to the item* being deleted to the function • If leftsubtree is NULL and rightsubtree is NULL, we can set the passed pointer to NULL • If one of the subtrees is not NULL, we set the pointer to that subtree • If both subtrees are not NULL, we have to find the predecessor and copy the information from the predecessor. Then the predecessor gets deleted. The program in the textbook is unnecessarily long

  47. Delete Function Hierarchy • A public member function is invoked by the client code passing the key of the element to be deleted as a parameter • This function calls a helper function passing it the key and the root pointer • The helper function searches for the key and calls an auxiliary function when the key is matched • This auxiliary function deletes the node containing the key using matches to identify cases A, B or C

More Related