1. 1 5 Linked Structures Based on Levent Akın’s CmpE160 Lecture Slides 3 Binary Trees

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

3. 3 Definition of Tree A tree is a finite set of one or more nodes such that: There is a specially designated node called the root. The remaining nodes are partitioned into n>=0 disjoint sets T 1,..., T n, where each of these sets is a tree. We call T 1,..., T n the subtrees of the root. Definition

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

5. 5 Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEAF NODES Leaf Nodes have No Children

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

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

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

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

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

11. 11 Terminology The degree of a node is the number of subtrees of the node The node with degree 0 is a leaf or terminal node. All other nodes are nonterminals. The degree of a tree is the maximum degree of the nodes of a tree.

12. 12 Terminology A node that has subtrees is the parent of the roots of the subtrees. The roots of these subtrees are the children of the node. Children of the same parent are siblings. The ancestors of a node are all the nodes along the path from the root to the node The height or depth of a tree is the maximum level of any node in the tree.

13. 13 Level and Depth Level 1 2 3 4 3 2 13 2 0 0 1 00 0 0 0 1 22 2 33 3 3 3 3 4 4 4 Sample Tree

14. Tree Representations For a tree of degree k (also called a k-ary tree), we could define a node structure that contains a data field plus k link fields. Advantage: uniform node structure (can insert/delete nodes without having to change node structure)‏ Disadvantage: many null link fields datalink 1link 2...link k

15. Tree Representations (continued)‏ In general, for a tree of degree k with n nodes, we know that the total number of link fields in the tree is kn and that exactly n-1 of them are not null. Therefore the number of null links is kn - (n-1) = (k-1)n + 1. degreeproportion of links that are null 2( n +1)/2 n, or about 1/2 3(2 n +1)/3 n, or about 2/3 4(3 n +1)/4 n, or about 3/4

16. 16 Percentage of Null links

17. Tree Representations (continued)‏ Clearly, to reduce the proportion of null links, we need to reduce the degree of the tree. An alternative representation for a tree of degree k: Use a left child-right sibling representation. Each node has two pointers, one to its left child and one to its right sibling.

18. 18 Left Child - Right Sibling A BCD E F G H I J K L M data left child right sibling

19. 19 J IM H L A B C D E F G K Left Child –Right Sibling representation

20. 20 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. Binary Tree

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

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

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

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

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

26. 26 Node Terminology for a Tree Node

27. 27 A B AB A B CGEIDHF Complete Binary Tree Skewed Binary Tree ECD 1 2 3 4 5 Samples of Binary Trees

28. 28 The maximum number of nodes on level i of a binary tree is 2 i-1, i≥1. The maximum number of nodes in a binary tree of depth k is 2 k -1, k ≥ 1. Prove by induction. Maximum Number of Nodes in BT

29. 29 For any nonempty binary tree, T, if n 0 is the number of leaf nodes and n 2 the number of nodes of degree 2, then n 0 =n 2 +1 proof: Let n and B denote the total number of nodes & branches in T. Let n 0, n 1, n 2 represent the nodes with no children, single child, and two children respectively. n= n 0 +n 1 +n 2, B+1=n, B=n 1 +2n 2 ==> n 1 +2n 2 +1= n, n 1 +2n 2 +1= n 0 +n 1 +n 2 ==> n 0 =n 2 +1 Relations between Number of Leaf Nodes and Nodes of Degree 2

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

31. 31 Definitions (cont.)‏ 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

32. 32 Examples of Different Types of Binary Trees

33. 33 A full binary tree of depth k is a binary tree of depth k having 2 -1 nodes, k ≥ 0. A binary tree with n nodes and depth k is complete iff its nodes correspond to the nodes numbered from 1 to n in the full binary tree of depth k. k A B C G E I D H F A B C G E K D J F I H O N M L Full binary tree of depth 4 Complete binary tree Full BT VS Complete BT

34. 34 A Binary Tree and Its Array Representation

35. 35 With Array 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].

36. 36 Sequential representation A B -- C -- D --. E [0] [1] [2] [3] [4] [5] [6] [7] [8]. [15] [0][1][2][3][4][5][6][7][8][0][1][2][3][4][5][6][7][8] ABCDEFGHIABCDEFGHI ABECDABCGEIDHF (1) space waste (2) insertion/deletion problem

37. 37 typedef struct node *treePointer; typedef struct node { ItemType data; treePointer leftChild; treePointer rightChild; }; dataleftChild rightChild data leftChild rightChild Linked Representation

38. 38 Let L, V, and R stand for moving left, visiting the node, and moving right. There are six possible combinations of traversal LVR, LRV, VLR, VRL, RVL, RLV Adopt convention that we traverse left before right, only 3 traversals remain LVR, LRV, VLR inorder, postorder, preorder Binary Tree Traversals

39. 39 +*A*/EDCB Arithmetic Expression Using BT

40. 40 void inorder(treePointer ptr)‏ // inorder tree traversal { if (ptr!=NULL) { inorder(ptr->leftChild); visit(ptr->data); inorder(ptr->rightChild); } A / B * C * D + E Inorder Traversal (recursive version)‏

41. 41 void preorder(treePointer ptr)‏ // preorder tree traversal { if (ptr!=NULL) { visit(ptr->data); preorder(ptr->leftChild); preorder(ptr->rightChild); } + * * / A B C D E Preorder Traversal (recursive version)‏

42. 42 void postorder(treePointer ptr)‏ // postorder tree traversal { if (ptr!=NULL) { postorder(ptr->leftChild); postorder(ptr->rightChild); visit(ptr->data); } A B / C * D * E + Postorder Traversal (recursive version)‏

43. 43 O(n)‏ Iterative Inorder Traversal (using stack)‏ void iter_inorder(treePointer node)‏ { StackType NodeStack; bool completed=false; while (!completed) { while(node!=NULL){ NodeStack.push(node); // add to stack node=node->leftChild } NodeStack.pop(node); // delete from stack if (node!=NULL){ cout data; node = node->rightChild; } else completed=true; }

44. 44 Trace Operations of Inorder Traversal

45. 45 Level Order Traversal (using queue)‏ void level_order(treePointer ptr)‏ /* level order tree traversal */ { QueueType NodeQueue; if (ptr!=NULL) { NodeQueue.enqueue(ptr); for (;;) { NodeQueue.dequeue(ptr);

46. 46 if (ptr!=NULL) { cout data; if (ptr->leftChild)‏ NodeQueue.enqueue(ptr->leftChild); if (ptr->rightChild!=NULL)‏ NodeQueue.enqueue(ptr->rightChild); } else break; } + * E * D / C A B

47. 47 +*A*/EDCB inorder traversal A / B * C * D + E infix expression preorder traversal + * * / A B C D E prefix expression postorder traversal A B / C * D * E + postfix expression level order traversal + * E * D / C A B Arithmetic Expression Using BT

48. 48 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. A Binary Search Tree (BST) is...

49. 49 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. Shape of a binary search tree... ‘J’

50. 50 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. Inserting ‘E’ into the BST ‘J’ ‘E’

51. 51 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. Inserting ‘F’ into the BST ‘J’ ‘E’ ‘F’

52. 52 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. Inserting ‘T’ into the BST ‘J’ ‘E’ ‘F’ ‘T’

53. 53 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. Inserting ‘A’ into the BST ‘J’ ‘E’ ‘F’ ‘T’ ‘A’

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

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

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

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

58. 58 Class TreeType // Assumptions: Relational operators overloaded class TreeType { public: // Constructor, destructor, copy constructor... // Overloads assignment... // Observer functions... // Transformer functions... // Iterator pair... void Print(std::ofstream& outFile) const; private: TreeNode* root; };

59. 59 bool TreeType::IsFull() const { NodeType* location; try { location = new NodeType; delete location; return false; } catch(std::bad_alloc exception)‏ { return true; } bool TreeType::IsEmpty() const { return root == NULL; }

60. 60 Tree Recursion CountNodes Version 1 if (Left(tree) is NULL) AND (Right(tree) is NULL)‏ return 1 else return CountNodes(Left(tree)) + CountNodes(Right(tree)) + 1 What happens when Left(tree) is NULL?

61. 61 Tree Recursion CountNodes Version 2 if (Left(tree) is NULL) AND (Right(tree) is NULL)‏ return 1 else if Left(tree) is NULL return CountNodes(Right(tree)) + 1 else if Right(tree) is NULL return CountNodes(Left(tree)) + 1 else return CountNodes(Left(tree)) + CountNodes(Right(tree)) + 1 What happens when the initial tree is NULL?

62. 62 Tree Recursion CountNodes Version 3 if tree is NULL return 0 else if (Left(tree) is NULL) AND (Right(tree) is NULL)‏ return 1 else if Left(tree) is NULL return CountNodes(Right(tree)) + 1 else if Right(tree) is NULL return CountNodes(Left(tree)) + 1 else return CountNodes(Left(tree)) + CountNodes(Right(tree)) + 1 Can we simplify this algorithm?

63. 63 Tree Recursion CountNodes Version 4 if tree is NULL return 0 else return CountNodes(Left(tree)) + CountNodes(Right(tree)) + 1 Is that all there is?

64. 64 // Implementation of Final Version int CountNodes(TreeNode* tree); // Pototype int TreeType::LengthIs() const // Class member function { return CountNodes(root); } int CountNodes(TreeNode* tree)‏ // Recursive function that counts the nodes { if (tree == NULL)‏ return 0; else return CountNodes(tree->left) + CountNodes(tree->right) + 1; }

65. 65 Retrieval Operation

66. 66 Retrieval Operation void TreeType::RetrieveItem(ItemType& item, bool& found)‏ { Retrieve(root, item, found); } void Retrieve(TreeNode* tree, ItemType& item, bool& found)‏ { if (tree == NULL)‏ found = false; else if (item info) Retrieve(tree->left, item, found);

67. 67 Retrieval Operation, cont. else if (item > tree->info)‏ Retrieve(tree->right, item, found); else { item = tree->info; found = true; }

68. 68 The Insert Operation A new node is always inserted into its appropriate position in the tree as a leaf.

69. 69 Insertions into a Binary Search Tree

70. 70 The recursive InsertItem operation

71. 71 The tree parameter is a pointer within the tree

72. 72 Recursive Insert 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); }

73. 73 Deleting a Leaf Node

74. 74 Deleting a Node with One Child

75. 75 Deleting a Node with Two Children

76. 76 DeleteNode Algorithm 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

77. 77 Code for DeleteNode 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;} else { GetPredecessor(tree->left, data); tree->info = data; Delete(tree->left, data); }

78. 78 Definition of Recursive Delete Definition: Removes item from tree Size: The number of nodes in the path from the root to the node to be deleted. Base Case: If item's key matches key in Info(tree), delete node pointed to by tree. General Case: If item < Info(tree), Delete(Left(tree), item); else Delete(Right(tree), item).

79. 79 Code for Recursive Delete 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 }

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

81. 81 Printing all the Nodes in Order

82. 82 Function Print Definition: Prints the items in the binary search tree in order from smallest to largest. Size: The number of nodes in the tree whose root is tree Base Case: If tree = NULL, do nothing. General Case: Traverse the left subtree in order. Then print Info(tree). Then traverse the right subtree in order.

83. 83 Code for Recursive InOrder Print 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?

84. 84 Destructor void Destroy(TreeNode*& tree); TreeType::~TreeType()‏ { Destroy(root); } void Destroy(TreeNode*& tree)‏ { if (tree != NULL)‏ { Destroy(tree->left); Destroy(tree->right); delete tree; }

85. 85 Algorithm for Copying a Tree if (originalTree is NULL)‏ Set copy to NULL else Set Info(copy) to Info(originalTree)‏ Set Left(copy) to Left(originalTree)‏ Set Right(copy) to Right(originalTree)

86. 86 Code for CopyTree 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); }

87. 87 Inorder(tree)‏ if tree is not NULL Inorder(Left(tree))‏ Visit Info(tree)‏ Inorder(Right(tree))‏ To print in alphabetical order

88. 88 Postorder(tree)‏ if tree is not NULL Postorder(Left(tree))‏ Postorder(Right(tree))‏ Visit Info(tree)‏ Visits leaves first (good for deletion)

89. 89 Preorder(tree)‏ if tree is not NULL Visit Info(tree)‏ Preorder(Left(tree))‏ Preorder(Right(tree))‏ Useful with binary trees (not binary search trees)

90. 90 Three Tree Traversals

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

92. 92 Code for ResetTree 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; }

93. 93 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; } Code for GetNextItem

94. 94 Iterative Versions FindNode 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

95. 95 void FindNode(TreeNode* tree, ItemType item, TreeNode*& nodePtr, TreeNode*& parentPtr)‏ { nodePtr = tree; parentPtr = NULL; bool found = false; while (nodePtr != NULL && !found)‏ { if (item info)‏ { parentPtr = nodePtr; nodePtr = nodePtr->left; } else if (item > nodePtr->info)‏ { parentPtr = nodePtr; nodePtr = nodePtr->right; } else found = true; } Code for FindNode

96. 96 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);

97. 97 Using function FindNode to find the insertion point

98. 98 Using function FindNode to find the insertion point

99. 99 Using function FindNode to find the insertion point

100. 100 Using function FindNode to find the insertion point

101. 101 Using function FindNode to find the insertion point

102. 102 AttachNewNode if item < Info(parentPtr)‏ Set Left(parentPtr) to newNode else Set Right(parentPtr) to newNode

103. 103 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

104. 104 Code for InsertItem void TreeType::InsertItem(ItemType item)‏ { TreeNode* newNode; TreeNode* nodePtr; TreeNode* parentPtr; newNode = new TreeNode; newNode->info = item; newNode->left = NULL; newNode->right = NULL; FindNode(root, item, nodePtr, parentPtr); if (parentPtr == NULL) root = newNode; else if (item info)‏ parentPtr->left = newNode; else parentPtr->right = newNode; }

105. 105 Code for DeleteItem 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); }

106. 106 PointersnodePtr and parentPtr Are External to the Tree

107. 107 Pointer parentPtr is External to the Tree, but parentPtr-> left is an Actual Pointer in the Tree

108. 108 A Binary Search Tree Stored in an Array with Dummy Values