Exploring Tree Structures: Definitions and Representations

1. CH5. TREES

2. 5.1 Introduction 5.1.1 Terminology • Tree : a finite set of one or more nodes • there is a specially designated node called the root • the remaining nodes are partitioned into n 0 disjoint sets T1, ..., Tn, where each of these sets is a tree. T1, ..., Tn are called the subtrees of the root. • Degree of a node : the number of subtrees of a node • Leaf (terminal node) : a node that has degree zero • Nonterminals : the other nodes • Children, parent, siblings • Degree of a tree : the maximum of degree of the nodes in the tree

3. 5.1 Introduction(Cont’) • Ancestors of a node : all the nodes along the path from the root to that node • Level of a node : the distance from the root+1 • Height (or depth) of a tree : the maximum level of any node in the tree

4. 5.1 Introduction(Cont’) Figure 5.1 : Two types of genealogical charts

5. A B C D E F G H I J K L M 5.1 Introduction(Cont’) Figure 5.2 : A sample tree

6. 5.1 Introduction(Cont’) 5.1.2 Representation of Trees • List representation • the tree of Figure 5.2 (A(B(E(K,L),F),C(G),D(H(M),I,J))) • the degree of each node may be different • possible to use memory nodes with a varying number of pointer fields • easier to write algorithms when the node size is fixed • nodes of a fixed size • for a tree of degree k • Lemma : If T is a k-ary tree with n nodes, each having a fixed size, then n(k-1)+1 of the nk child fields are 0, n 1

7. A 0 B F 0 C G 0 D I J 0 E K L 0 H M 0 5.1 Introduction(Cont’) Figure 5.3 : List representation of the tree of Figure 5.2

8. A B D C E F G H J I K L M 5.1 Introduction(Cont’) • Left child-right sibling representation • node structure • the left child field of each node points to its leftmost child (if any), and the right sibling field points to its closest right sibling (if any) Figure 5.6 : Left child-right sibling representation of the tree of Figure 5.2

9. A B A C E B B K D F G L H M I J 5.1 Introduction(Cont’) • Representation as a degree-two tree • rotate the right-sibling pointers clockwise by 45 degrees • the two children of a node are referred to as the left and right children Figure 5.7 : Left child-right child tree representation

10. A A A B B B A B C A A B C B C 5.1 Introduction(Cont’) • additional examples Figure 5.8 : Tree representations • left child-right child tree : binary tree • any tree can be represented as a binary tree

11. A A B B 5.2 Binary Trees 5.2.1 The Abstract Data Type • A binary tree a finite set of nodes that either is empty or consists of a root and two disjoint binary trees called the left subtree and the right subtree • Differences between a binary tree and a tree • there is an empty binary tree • the order of the children is distinguished in a binary tree • Complete binary tree and Full binary tree (Fig. 5.10, Fig. 5.11) Figure 5.9 : Two different binary trees

12. 5.2 Binary Trees(Cont’) template <class KeyType> class BinaryTree { // objects: A finite set of nodes either empty or consisting of a root // node, left BinaryTree and right BinaryTree. public: BinaryTree(); // creates an empty binary tree Boolean IsEmpty(); // if the binary tree is empty, return TRUE (1); else return // FALSE (0) BinaryTree(BinaryTree bt 1, Element<KeyType> item, BinaryTree bt 2); // creates a binary tree whose left subtree is bt 1, whose right // subtree is bt 2, and whose root node contains item

13. 5.2 Binary Trees(Cont’) • BinaryTree Lchild(); • // if IsEmpty(), return error; else return the left subtree of *this • Element<KeyType> Data(); • // if IsEmpty(), return error; else return the data • // in the root node of *this • BinaryTree Rchild(); • // if IsEmpty(), return error; else return the right subtree of *this • }; ADT 5.1 : Abstract data type BinaryTree

14. A A B B C C D G E F D H I E 5.2 Binary Trees(Cont’) Figure 5.10 : Skewed and complete binary trees

15. 5.2 Binary Trees(Cont’) 5.2.2 Properties of Binary Trees • Lemma 5.2 [Maximum number of nodes] (1) The max number of nodes on level i of a binary tree is 2i-1, i≥ 1 (2) The max number of nodes in a binary tree of depth k is 2k-1, k≤ 1 • Lemma 5.3 [Relation between number of leaf nodes and degree-2 nodes] For any non-empty binary tree, T, if n0 is the number of leaf nodes and n2 the number of nodes of degree 2, then n0=n2+1 • A full binary tree of depth k • a binary tree of depth k having 2k-1 nodes, k≥ 0

16. 5.2 Binary Trees(Cont’) 1 2 3 4 5 6 7 10 11 13 8 9 12 14 15 Figure 5.11 : Full binary tree of depth 4 with sequential node numbers

17. 5.2 Binary Trees(Cont’) • A binary tree with n nodes and depth k is complete • its nodes correspond to the nodes numbered from 1 to n in the full binary tree of depth k • The height of a complete binary tree with n nodes is

18. 5.2 Binary Trees(Cont’) 5.2.3 Binary Tree Representation • Array representation • Lemma 5.4 : If a complete binary tree with n nodes is represented sequentially, then for any node with index i, 1≤ i≤ n, we have (1) parent(i) is at if i ≠1. If i=1, i is at the root and has no parent (2) LeftChild(i) is at 2i if 2i≤ n. If 2i>n, then i has no left child (3) RightChild(i) is at 2i+1 if 2i+1≤ n. If 2i+1>n, then i has no right child

19. 5.2 Binary Trees(Cont’) Figure 5.12 : Array representation of the binary trees of Figure 5.10

20. 5.2 Binary Trees(Cont’) • Linked representation • classes to define a tree class Tree; //forward declaration class TreeNode { friend class Tree; private: TreeNode *LeftChild; char data; TreeNode *RightChild; }; class Tree { public: // Tree operations ... private: TreeNode *root; };

21. 5.2 Binary Trees(Cont’) data Figure 5.13 : Node representations

22. A B C D E 5.2 Binary Trees(Cont’)

23. A B C D G E F H I 5.2 Binary Trees(Cont’) Figure 5.14 : Linked representation for the binary trees of Figure 5.10

24. A B D C E 5.2 Binary Trees(Cont’) Figure 5.15 : Binary tree for Exercise 1

25. 5.3 Binary Tree Traversal and TreeIterators 5.3.1 Introduction • Tree traversal • visiting each node in the tree exactly once • a full traversal produces a linear order for the nodes • Order of node visit L : move left V : visit node R : move right • possible combinations : LVR, LRV, VLR, VRL, RVL, RLV • traverse left before right • LVR : inorder • LRV : postorder • VLR : preorder

26. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) + * E * D C / B A Figure 5.16 : Binary tree with arithmetic expression

27. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) 5.3.2 Inorder Traversal • LVR void Tree::inorder() // Driver call workhorse for traversal of entire tree. The driver is // declared as a public member function of Tree. { inorder(root); } void Tree::inorder(TreeNode *CurrentNode) // Workhorse traverses the subtree rooted at CurrentNode (which is // a pointer to a node in a binary tree). The workhorse is declared // as a private member function of Tree. { if (CurrentNode) { inorder(CurrentNode->LeftChild); cout << CurrentNode->data; inorder(CurrentNode->RightChild); } } Program 5.1 : Inorder traversal of a binary tree

28. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) Figure 5.17 : Trace of Program 5.1

29. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) • Output : A/B*C*D+E • infix form of the expression

30. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) 5.3.3 Preorder Traversal • VLR void Tree::preorder() { // Driver calls workhorse for traversal of entire tree. The driver is // declared as a public member function of Tree. preorder(root); } void Tree::preorder(TreeNode *CurrentNode) // Workhorse traverses the subtree rooted at CurrentNode (which is // a pointer to a node in a binary tree). The workhorse is declared // as a private member function of Tree. { if (CurrentNode) { cout << CurrentNode->data; preorder(CurrentNode->LeftChild); preorder(CurrentNode->RightChild); } } Program 5.2 : Preorder traversal of a binary tree

31. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) • Output : +**/ABCDE • prefix form of the expression

32. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) 5.3.4 Postorder Traversal • LRV void Tree::postorder() { // Driver calls workhorse for traversal of entire tree. The // driver is declared as a public member function of Tree. postorder(root); } void Tree::postorder(TreeNode *CurrentNode) // Workhorse traverses the subtree rooted at // CurrentNode (which is a pointer to a node in a binary tree). // The workhorse is declared as a private member function of Tree { if (CurrentNode) { postorder(CurrentNode->LeftChild); postorder(CurrentNode->RightChild); cout << CurrentNode->data; } } Program 5.3 : Postorder traversal of a binary tree

33. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) • Output : AB/C*D*E+ • postfix form of the expression

34. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) 5.3.5 Iterative Inorder Traversal • Tree is a container class • may implement a tree traversal algorithm by using iterators • the algorithm needs to be non-recursive • use template Stack class • Definition • a data object of Type A USES-A data object of Type B if a Type A object uses a Type B object to perform a task • this relationship is typically expressed by employing the Type B object in a member function of Type A

35. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) void Tree::NonrecInorder() // nonrecursive inorder traversal using a stack { Stack<TreeNode *> s; // declare and initialize stack TreeNode *CurrentNode = root; while(1) { while(CurrentNode){ // move down LeftChild fields s.add(CurrentNode); // add to stack CurrentNode = CurrentNode->LeftChild; } if (!s.IsEmpty()) { // stack is not empty CurrentNode = *s.Delete(CurrentNode); // delete from stack cout << CurrentNode->data << endl; CurrentNode = CurrentNode->RightChild; } else break; } } Program 5.4 : Nonrecursive inorder traversal

36. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) • Iteration • each iteration of the while loop (lines 6-17) yields the next element in the inorder traversal class InorderIterator { public: char *Next(); InorderIterator(Tree tree) : t(tree) {CurrentNode = t.root;}; private: Tree t; Stack <TreeNode *> s; TreeNode *CurrentNode; }; Program 5.5 : Definition of inorder iterator class

37. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) char *InorderIterator::Next() { while(CurrentNode) { s.add(CurrentNode); CurrentNode = CurrentNode->LeftChild; } if (!s.IsEmpty()) { CurrentNode = *s.Delete(CurrentNode); char &temp = CurrentNode->data; CurrentNode = CurrentNode->RightChild; //update CurrentNode return &temp; } else return 0; // tree has been traversed. no more elements } Program 5.6 : Code for obtaining the next inorder element

38. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) 5.3.6 Level-Order Traversal • Root-left child-right child • requires a queue void Tree::LevelOrder() // Traverse the binary tree in level order { QUEUE<TreeNode*> q; TreeNode *CurrentNode = root; while(CurrentNode) { cout<<CurrentNode->data<<endl; if (CurrentNode->LeftChild) q.add(CurrentNode->LeftChild); if (CurrentNode->RightChild) q.add(CurrentNode->RightChild); CurrentNode = *q.Delete(CurrentNode); } } Program 5.7 : Level-order traversal of a binary tree

39. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) • Output : +*E*D/CAB • used the circular queue

40. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) void tree :: NoStackInorder() //inorder traversal of binary tree using a fixed amount of additional storage { if(!root) return; // empty binary tree TreeNode *top = 0, *LastRight=0, *p, *q, *r, *r1; p=q=root; while(1) { while(1) { if((!pLeftChild)&&(!pRightChild)) { //leaf node cout < < p  data; break; } if (!pLeftChild) { //visit p and move to p  RightChild cout < < p  data; r=pRightChild; pRightChild=q; q=p; p=r; } else{ //move to p  LeftChild r=pLeftChild; pLeftChild = q; q=p; p=r; } } //end of inner while

41. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) //p is a leaf node, move upward to a node whose //right subtree has not yet been examined TreeNode *av = p; while(1) { if(p = = root) return; if(!qLeftChild) { // q is linked via RightChild r = q RightChild; qRightChild = p; p = q; q=r; } else if (!qRightChild){ // q is linked via LeftChild r=qLeftChild; qLeftChild = p; p=q; q=r; cout << p data; } else //check if p is a RightChild of q if(q = = LastRight ){ r = top; LastRight = r  LeftChild; top = r  RightChild; // unstack r  LeftChild = r  RightChild = p; p = q; q = r; }

42. 5.3 Binary Tree Traversal and Tree Iterators(Cont’) else { // p is LeftChild of q cout <<qdata; // visit q av  LeftChild = LastRight; av RightChild = top; top = av; LastRight = q; r = q  LeftChild; q  LeftChild = p; // restore link to p r1 = q  RightChild; q  RightChild = r; p = r1; break; } } // end of inner while loop } // end of outer while loop } Program 5.8 : O(1) space inorder traversal

43. 5.4 Additional Binary Tree Operations //Copy consturctor Tree :: Tree(const Tree&s) //driver { root = copy(s.root); } TreeNode*Tree :: copy(TreeNode *orignode) // Workhorse //This function returns a pointer to an exact copy of the binary tree rooted at orignode. { if(orignode) { TreeNode *temp = new TreeNode; temp  data = orignode  data; temp  LeftChild = copy (orignode  LeftChild); temp  RightChild = copy (orignode  RightChild); return temp; } else return 0; } Program 5.9 : Copying a binary tree

44. 5.4 Additional Binary Tree Operations(Cont’) //Driver – assumed to be a friend of class Tree. int operator = = (const Tree & s, const Tree & t) { return equal (s.root, t.root); } //Workhorse – assumed to be a friend of TreeNode. int equal (TreeNode *a, TreeNode *b) //This function returns 0 if the subtrees at a and b are not equivalent. //Otherwise, it will return 1. { if ((!a)&&(!b)) return 1; //both a and b are 0 if (a&&b // both a and b are non-0 && (adata = = b  data) //data is the same && equal (a LeftChild, b LeftChild) //left subtrees are the same && equal (a RightChild, b RightChild)) // right subtrees are the same return 1; return 0; } Program 5.10 : Binary tree equivalence

45. 5.4 Additional Binary Tree Operations(Cont’) Figure 5.18 : Propositional formula in a binary tree

46. 5.4 Additional Binary Tree Operations(Cont’) for all 2n possible truth value combinations for the n variables { generate the next combinationl replace the variables by their values; evaluate the formula by traversing the tree it points to in postorder; if(formula.rootvalue()) { cout << combination ; return; } } cout << “no satisfiable combination”; Program 5.11 : First version of satisfiability algorithm

47. 5.4 Additional Binary Tree Operations(Cont’) void SatTree :: PostOrderEval() // Driver { PostOrderEval(root); } void SatTree :: PostOrderEval(SatNode *s) // Workhorse { if(s) { PostOrderEval(sLeftChild); PostOrderEval(sRightChild); switch(sdata) { case LogicalNot: svalue = !s RightChildvalue; break; case LogicalAnd: svalue = sLeftChildvalue&& sRightChildvalue; break; case LogicalOr: svalue = sLeftChildvalue|| sRightChildvalue; break; case LogicalTrue: svalue = TRUE; break; case LogicalFalse: svalue = FALSE; } } } Program 5.12 : Evaluating a formula

48. 5.4 Additional Binary Tree Operations(Cont’) Figure 5.19 : A SwapTree example

49. 5.5 Threaded Binary Trees Figure 5.20 : Threaded tree corresponding to Figure 5.10(b)

50. 5.5 Threaded Binary Trees(Cont’) Figure 5.21 : An empty threaded binary tree