1. Chapter 8 Binary Search Trees

2. 2 Goals Define and use the following terminology: binary tree root descendant subtree binary search tree parent level ancestor child height Define a binary search tree at the logical level Show what a binary search tree would look like after a series of insertions and deletions

3. 3 Goals Implement the following binary search tree algorithms in C++ Inserting an element Deleting an element Retrieving an element Modifying an element Copying a tree Traversing a tree in preorder, inorder, postorder

4. 4 Goals Discuss the Big-O efficiency of a given binary search tree operation Describe an algorithm for balancing a binary search tree Show how a binary tree can be represented in an array, with implicit positional links between the elements Define the terms full binary tree and complete binary tree

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

6. 6 Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len ROOT NODE Trees

7. 7 Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEAF NODES Trees

8. 8 Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEVEL 0 Trees

9. 9 Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEVEL 1 Trees

10. 10 Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEVEL 2 Trees

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

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

13. 13 Trees Binary Tree A structure with a unique starting node (the root), in which each node is capable of having two child nodes and a unique path exists from the root to every other node Root The top node of a tree structure; a node with no parent Leaf Node A tree node that has no children

14. 14 Trees Level Distance of a node from the root Height The maximum level

15. 15 Trees Why is this not a tree ?

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

17. 17 Trees Q V T K S A E L Q has how many descendant?

18. 18 Trees Q V T K S A E L S has how many ancestors?

19. 19 Trees How many different binary trees can be made from 2 nodes? 4 nodes? 6 nodes?

20. 20 Binary Search Trees A binary tree in which the key value in any node is greater than the key value in the left child and any of its children and less than the key value in the right child and any of its children A BST is a binary tree with the search property

21. 21 Binary Search Trees Each node is the root of a subtree

22. 22 Recursive Implementation

23. 23 Recursive Count Let’s start by counting the number of nodes in a tree Size? Base cases(s)? General case(s)?

24. 24 Recursive Count Count (Version 1) if (Left(tree) is NULL) AND (Right(tree) is NULL) return 1 else return Count (Left(tree)) + Count(Right(tree)) + 1 Apply to these trees

25. 25 Recursive Count Count (Version 2) if (left(tree) is NULL) AND (Right(tree) is NULL) return 1 else if (Left(tree) is NULL) return Count(Right(tree)) + 1 else if (Right(tree) is NULL) return Count(Left(tree)) + 1 else return Count(Left(tree)) + Count(Right(tree)) + 1 Apply to an empty tree

26. 26 Recursive Count Count (Version 3) if (tree is NULL) // Version 2 Stop Count (Version 4) if (tree is NULL) return 0 else return Count(Left(tree)) + Count(Right(tree)) + 1

27. 27 Recursive Count int TreeType() const { return Count(root); ) int Count(TreeNode* tree) { if (tree == NULL) return 0 else return Count(tree->left) + Count(tree->right) + 1; } Why do we need two functions?

28. 28 Recursive Search ‘J’ ‘E’ ‘A’ ‘H’ ‘T’ ‘M’ ‘K’ ‘V’ ‘P’ ‘Z’‘D’‘Q’‘L’‘B’‘S’ Are ‘D’, ‘Q’, and ‘N’ in the tree?

29. 29 Recursive Search Retrieve(tree, item, found) Size? Base case(s)? General case(s)?

30. 30 Recursive Search void Retrieve(TreeNode* tree, ItemType& item, bool& found) { if (tree == NULL) found = false; else if (item info) Retrieve(tree->left, item, found); else if (item > tree->info) Retrieve(tree->right, item, found); else { item = tree->info; found = true; }

31. 31 Shape depends on the order of item insertion Insert the elements ‘J’ ‘E’ ‘F’ ‘T’ ‘A’ in that order The first value inserted is always put in the root Shape of BST ‘J’

32. 32 Thereafter, each value to be inserted compares itself to the value in the root node moves left it is less or moves right if it is greater When does the process stop? Shape of BST ‘J’ ‘E’

33. 33 Trace path to insert ‘F’ Shape of BST ‘J’ ‘E’ ‘F’

34. 34 Trace path to insert ‘T’ Shape of BST ‘J’ ‘E’ ‘F’ ‘T’

35. 35 Trace path to insert ‘A’ Shape of BST ‘J’ ‘E’ ‘F’ ‘T’ ‘A’

36. 36 Now build tree by inserting ‘A’ ‘E’ ‘F’ ‘J’ ‘T’ in that order Shape of BST And the moral is?

37. 37 Recursive Insertion Insert an item into a tree Where does each new node get inserted? Insert(tree, item) if (tree is NULL) Get a new node Set right and left to NULL Set info to item

38. 38 Recursive Insertion

39. 39 Recursive Insertion

40. 40 Recursive Insertion How must the tree be passed?

41. 41 Recursive Insertion void Insert(TreeNode*& tree, ItemType item) { if (tree == NULL) {// Insertion place found. tree = new TreeNode; tree->right = NULL; tree->left = NULL; tree->info = item; } else if (item info) Insert(tree->left, item); else Insert(tree->right, item); }

42. 42 Recursive Deletion Delete ‘Z’

43. 43 Recursive Deletion Delete ‘R’

44. 44 Recursive Deletion Delete ‘Q’

45. 45 Recursive Deletion Can you summarize the three deletion cases?

46. 46 Recursive Deletion DeleteItem(tree, item ) if (Left(tree) is NULL) AND (Right(tree) is NULL) Set tree to NULL else if Left(tree) is NULL Set tree to Right(tree) else if Right(tree) is NULL Set tree to Left(tree) else Find predecessor Set Info(tree) to Info(predecessor) Delete predecessor

47. 47 Recursive Deletion void Delete(TreeNode*& tree, ItemType item) { if (item info) Delete(tree->left, item); else if (item > tree->info) Delete(tree->right, item); else DeleteNode(tree); // Node found }

48. 48 Recursive Deletion void DeleteNode(TreeNode*& tree) { ItemType data; TreeNode* tempPtr; tempPtr = tree; if (tree->left == NULL) { tree = tree->right; delete tempPtr; } else if (tree->right == NULL){ tree = tree->left; delete tempPtr;} els{ GetPredecessor(tree->left, data); tree->info = data; Delete(tree->left, data);} }

49. 49 Recursive Deletion void GetPredecessor(TreeNode* tree, ItemType& data) { while (tree->right != NULL) tree = tree->right; data = tree->info; } Why is the code not recursive?

50. 50 Recursive Deletion

51. 51 Printing the Tree Apply same algorithm to each tree What is the order of the output?

52. 52 Printing the Tree PrintTree operation Size? Base case(s)? General case(s)?

53. 53 Printing the Tree void PrintTree(TreeNode* tree, std::ofstream& outFile) { if (tree != NULL) { PrintTree(tree->left, outFile); outFile info; PrintTree(tree->right, outFile); } Is that all there is ?

54. 54 A Question Do we need a destructor?

55. 55 Copying a Tree CopyTree(copy, originalTree) if (originalTree is NULL) Set copy to NULL else Set copy to new node Set Info(copy) to Info(originalTree) CopyTree(Left(copy), Left(originalTree)) CopyTree(Right(copy), Right(originalTree)) How must copy be passed? How must originalTree be passed?

56. 56 Copying a Tree void CopyTree(TreeNode*& copy, const TreeNode* originalTree) { if (originalTree == NULL) copy = NULL; else { copy = new TreeNode; copy->info = originalTree->info; CopyTree(copy->left, originalTree->left); CopyTree(copy->right, originalTree->right); }

57. 57 Traversals Inorder(tree) if tree is not NULL Inorder(Left(tree)) Visit Info(tree) Inorder(Right(tree)) PostOrder(tree) if tree is not NULL Postorder(Left(tree)) Postorder(Right(tree)) Visit Info(tree) PreOrder(tree) if tree is not NULL Visit Info(tree) Preorder(Left(tree)) Preorder(Right(tree)) alphabetic order destructor (why?) expression evaluation

58. 58 Traversals Each node is visited three times

59. 59 Traversals

60. 60 Iterator Approach l The client program passes a parameter to ResetTree and GetNextItem indicating which of the three traversals to use l ResetTree generates a queues of node contents in the indicated order l GetNextItem processes the node contents from the appropriate queue: inQue, preQue, postQue

61. 61 Iterator void TreeType::ResetTree(OrderType order) // Calls function to create a queue of the tree // elements in the desired order. { switch (order) { case PRE_ORDER : PreOrder(root, preQue); break; case IN_ORDER : InOrder(root, inQue); break; case POST_ORDER: PostOrder(root, postQue); break; }

62. 62 void TreeType::GetNextItem(ItemType& item, OrderType order,bool& finished) { finished = false; switch (order) { case PRE_ORDER : preQue.Dequeue(item); if (preQue.IsEmpty()) finished = true; break; case IN_ORDER : inQue.Dequeue(item); if (inQue.IsEmpty()) finished = true; break; case POST_ORDER: postQue.Dequeue(item); if (postQue.IsEmpty()) finished = true; break; } Iterator

63. 63 Iterative Versions FindNode(tree, item, nodePtr, parentPtr) Set nodePtr to tree Set parentPtr to NULL Set found to false while more elements to search AND NOT found if item < Info(nodePtr) Set parentPtr to nodePtr Set nodePtr to Left(nodePtr) else if item > Info(nodePtr) Set parentPtr to nodePtr Set nodePtr to Right(nodePtr) else Set found to true

64. 64 Iterative Versions InsertItem Create a node to contain the new item Find the insertion place Attach new node Find the insertion place FindNode(tree, item, nodePtr, parentPtr);

65. 65 Iterative Versions Insert 13

66. 66 Iterative Versions

67. 67 Iterative Versions AttachNewNode if item < Info(parentPtr) Set Left(parentPtr) to newNode else Set Right(parentPtr) to newNode See a problem ?

68. 68 Iterative Version AttachNewNode(revised) if parentPtr equals NULL Set tree to newNode else if item < Info(parentPtr) Set Left(parentPtr) to newNode else Set Right(parentPtr) to newNode

69. 69 Iterative Version void TreeType::DeleteItem(ItemType item) { TreeNode* nodePtr; TreeNode* parentPtr; FindNode(root, item, nodePtr, parentPtr); if (nodePtr == root) DeleteNode(root); else if (parentPtr->left == nodePtr) DeleteNode(parentPtr->left); else DeleteNode(parentPtr->right); } Why not parentPtr? Why not nodePtr?

70. 70 Iterative Version parentPtr and nodePtr are external; parentPtr->left is internal

71. 71 Recursion VS Iteration Compare versions of Tree algorithms Is the depth of recursion relatively shallow? Is the recursive solution shorter or cleaner? Is the recursive version much less efficient?

72. 72 Nonlinked Representation What is the mapping into the index?

73. 73 Nonlinked Representation For any node tree.nodes[index] its left child is in tree.nodes[index*2 + 1] right child is in tree.nodes[index*2 + 2] its parent is in tree.nodes[(index - 1)/2] Can you determine which nodes are leaf nodes?

74. 74 Nonlinked Representation Full Binary Tree A binary tree in which all of the leaves are on the same level and every nonleaf node has two children

75. 75 Nonlinked Representation Complete Binary Tree A binary tree that is either full or full through the next-to-last level, with the leaves on the last level as far to the left as possible

76. 76 Nonlinked Representation

77. 77 Nonlinked Representation A technique for storing a non- complete tree