Data Structures Fakhar lodhi Chapter 5: Trees

Size: px

Start display at page:

Download "Data Structures Fakhar lodhi Chapter 5: Trees"

Stewart Jennings
6 years ago
Views:

1 Chapter 5 Trees Introduction Linked-lists are essentially used to store and organize data where the relationship among data is linear or one-dimensional (a circular structure can be considered as a special case of a linear structure). A lot of data is however non-linear in nature. Examples of such data include hierarchical data organizations such as lineal charts, file directories, and table of contents of a book. Figure shows one such hierarchy which presents a section of the family tree of perhaps the most famous Arab tribe Banu- Quresh, highlighting lineage of the Holy Prophet Muhammad (PBUH). Such hierarchical organizations are very common and cannot be expressed with linear lists. We therefore need other data structures to model such organizations. Tree is perhaps the most important non-linear data structure with numerous applications in computing and other fields. This chapter is dedicated to the discussion of tree data structure. 5.1 Tree some definitions The elements of a tree are called nodes. A tree consists of a finite set of nodes and links. A link connects two nodes of a tree. Two nodes are said to be adjacent if they are directly connected by a link. A path is a sequence of adjacent nodes. Every node is connected to every other node in the tree through a unique path. A tree which does not have any node is called an empty tree. Our focus of interest is a special kind of tree called the ed tree. A ed tree is a non-empty tree which has a specially designated node called the node. By convention, ed trees are shown to grow downwards with the node shown at the top and serves as start or the entry point in to the tree. All other nodes are said to be descendents of the node. The direct descendents (nodes that have a direct link) of a node are called its children and the node itself is called the parent of those nodes. Children of the same node are called siblings. The node does not have any parent. Every other node has exactly one parent. A node may have 0 or Page 1 of 16

2 Haris Zubair Abu Talib Auf Husais Sehm Taiem Mugheera Taiem Zahra Mutlib Abdus Shams Naufil Muhammad (PBUH) Asad Nuzlah Luayy Qusayy Quresh Ghalib Muharib Ka'ab Amir Hirs Murrah Jamha Adi Kilab Makhzoom Abd Munaf Abdud Dar Abdul Uza Hashim Abu Amr Abu Ubaida Abdul Mutlib Aba' Saifi Abdullah Musa'ab Abu Lahab Maqoom Hajl Abbas Mugheera Hamza Zarrar Data Structures Fakhar lodhi Chapter 5: Trees Page 2 of 16

more children. A node with zero children is called a leaf node. Nodes other than the leaf nodes and the node are called internal or intermediate nodes.

3 more children. A node with zero children is called a leaf node. Nodes other than the leaf nodes and the node are called internal or intermediate nodes. That is, an intermediate node has exactly one parent and at least one child. A subset of a tree that can be viewed as a complete tree in itself is called a subtree. That is, a node with all its descendents is a subtree. In other words, every node in a tree can be seen as the node of the subtree ed at that node. The subtree corresponding to the node is the entire tree and hence a tree is defined and identified by its node. Figure shows a ed tree with A with nodes B, F, and K as its children/subtrees. Nodes B, F, K, C, D, and X are internal nodes whereas H, L, Q, G, M, I, N, and P are leaf nodes. Degree of a node is defined as the number of children of that node. In Figure, nodes H, L, Q, G, M, I, N, and P have degree 0, nodes F and X have degree 1, nodes B, K, and D have degree 2, and A and C have degree 3. Level of a node is defined as the distance of the node from the node. In Figure A is at level 0, B, F, and K are at level 1, C, H, D, L and X are level 2, and the rest are at level 3. Height of a tree is defined as the maximum level of any node in the tree 1. Height of tree in Figure is 3. 1 Definition of height and level is not standardized and may slightly vary from one text to the other. Page 3 of 16

5.2 Binary tree A binary tree is a special kind of ed tree with the property that all nodes in a binary tree have at most two children. That is, the maximum degree of a node in a binary tree is 2.

4 5.2 Binary tree A binary tree is a special kind of ed tree with the property that all nodes in a binary tree have at most two children. That is, the maximum degree of a node in a binary tree is 2. The two children of a node in a binary tree are usually designated as the left and right child. A binary tree can be defined recursively as the following: a) A binary tree is either empty or non-empty b) If the binary tree is non-empty then 1. There is a node 2. The node has two children, the left child and the right child. These children correspond to two subtrees the left subtree and the right subtree. 3. Each subtree is a binary tree. Figure (a) and (b) are examples of binary trees. In Figure (a), B is the left child of A and H is the right child of B. It can be very easily seen that the maximum number of nodes on level i of a binary tree is 2 i and the maximum number of nodes in a binary tree of height k is 2 k+1 1. A binary tree of height k having 2 k+1 1 nodes is called a full binary tree. A binary tree is a full binary tree if and only if all leaf nodes are at the same level and all other nodes have degree 2. Figure shows a full binary tree of height 4 with 15 nodes in it. Page 4 of 16

A complete binary tree is a binary tree that is completely filled, with the possible exception of the bottom level, which is filled from left to right.

for a node numbered i, assign 2*i and 2*i + 1 to its left and right children respectively.

5 A complete binary tree is a binary tree that is completely filled, with the possible exception of the bottom level, which is filled from left to right. Another way to determine whether a tree is complete or not is to assign numbers to all its nodes as follows: 1. node is assigned number for a node numbered i, assign 2*i and 2*i + 1 to its left and right children respectively. then the tree is a complete binary tree iff the maximum number thus assigned is equal to the number of nodes in the tree. Note that full binary tree is also a complete binary tree. Figure (a) is an example of a complete binary tree whereas the tree in Figure (b) is not complete. Page 5 of 16

6 5.3 Binary tree implementation using linked structures Binary trees can be easily implemented using dynamically created nodes which are linked through pointers. As shown in Figure, a binary tree node structure is quite similar to that of a doubly linked-list instead of having pointers to the next and previous nodes, in this case, we have pointers to the left and right children of the node. Some implementations also add a pointer to the parent node but in most cases this is not required. struct TreeNode { T data; TreeNode<T> *left, *right; ; We can now use this node structure to define our binary tree whose specification is shown in Figure class BinaryTree { public: BinaryTree(){ = NULL; // create an empty binary tree void buildbinarytree( T data, BinaryTree<T> &leftsubtree, BinaryTree<T> &rightsubtree); /************************************************************* This method can be used to build a binary tree bottoms up. The modified tree is ed at a node with the input data and its left and right children are made-up of the left and right subtrees passed as input parameters. The left and right subtrees passed as input lose their contents and their s are set to NULL. **************************************************************/ ~BinaryTree(){clear(); void inorder(){inorder(); // in-order traversal void preorder(){inorder(); // pre-order traversal void postorder(){inorder(); // post-order traversal BinaryTree(const BinaryTree & bt); // copy constructor const BinaryTree & operator=(const BinaryTree & rhs); // assignment operator private: TreeNode <T> *; friend class LNRIterator<T>; // in-order iterator TreeNode<T> * createtreenode(t data); void clear(treenode<t> *t); // cleanup tree void inorder(treenode<t> *t); // in-order workhorse void preorder(treenode<t> *t); // pre-order workhorse void postorder(treenode<t> *t); // post-order workhorse ; left data right Page 6 of 16

7 5.3.1 Building a binary tree Figure shows the methods to build the binary from bottom to top. TreeNode<T> * BinaryTree<T> :: createtreenode(t data) { TreeNode<T> *t = new TreeNode<T>; if (t!= NULL) { t->data = data; t->left = t->right = NULL; return t; else throw OUT_OF_MEMORY; void BinaryTree<T> :: buildbinarytree(t Data,BinaryTree<T> &leftsubtree, BinaryTree<T> &rightsubtree) { // create a new tree node and store data in it TreeNode<T> *t = createtreenode(data); // make the left and right of the new node point to the s // of the left and right sub-trees respectively t->left = leftsubtree->; t->right = rightsubtree->; // assign NULL to s of the input trees so that the nodes // that have now been shifted to the target tree are not // destroyed when the destructor is called for these trees. leftsubtree-> = NULL; rightsubtree-> = NULL; clear(); = t; // return any existing nodes in the tree to heap // make the new node the of the target tree There are a couple of points to be noted. 1. This method detaches the nodes present in the trees passed as input parameters and attaches those nodes to the tree which we are building from these sub-trees. Hence these trees are effectively destroyed by assigning NULL value to their s. 2. The second last statement in the method, clear(), is very important. It essentially destroys the target tree by returning any nodes attached to back to heap. Failing to do so could create garbage. Page 7 of 16

8 Figure (b to f) demonstrates how this method could be used to build the tree of Figure.(a) (a) t1 (b) NULL NULL NULL t2 nulltree BinaryTree<int> t1, t2, nulltree; (c) t1 1 3 t2 t1.buildtree(1,nulltree, nulltree); t2.buildtree(3,nulltree, nulltree); (d) t NULL t2 t1.buildtree(2,t1, t2); t1 4 t2 NULL 2 5 (e) t2 5 t2.buildtree(5, nulltree, nulltree); (f) 1 3 t1.buildtree(4,t1, t2); Page 8 of 16

9 5.3.2 Binary tree traversal It is often required to visit (access) each node in the tree and process data present in there. For that purpose some tree traversal algorithm is used which provides a systematic approach to access all the nodes in the tree. A complete traversal generates a linear order of all the nodes in the tree. As described in section 5.2, a non-empty tree is defined by the node pointed to by its and its two children the left subtree and the right subtree. These two subtrees are also trees ed at the left and right child of the parent node. A traversal algorithm can be developed easily by making use of this recursive definition. L Left subtree N - Node R Right subtree NLR process the node, then traverse the left subtree, then traverse the right subtree NRL process the node, then traverse the right subtree, then traverse the left subtree LNR traverse the left subtree, then process the node, then traverse the right subtree LRN traverse the left subtree, then traverse the right subtree, then process the node RNL traverse the right subtree, process the node, then then traverse the left subtree RLN traverse the right subtree, then traverse the left subtree, then process the node Let N, L, and R denote node, left subtree, and right subtree of a tree. As shown in Figure, these three letters (N, L, and R) can be arranged in six different permutations NLR, NRL, LNR, LRN, RNL, and RLN. These six permutations correspond to six different traversals of the binary tree. For example, LNR corresponds to a traversal in which we complete the tree traversal by first traversing the left subtree, then visiting the node, and then traversing the right subtree. If we always traverse left before right then we are left with three possible traversal NLR, LNR, and LRN. These three are called pre-order, in-order, and post-order respectively. C++ code for in-order and pre-order workhorse functions is given in Figure void BinaryTree<T> :: inorder(treenode<t> *t) { if (t!= NULL) { inorder(t->left); process(t); inorder(t->right); void BinaryTree<T> :: preorder(treenode<t> *t) { if (t!= NULL) { process(t); preorder(t->left); preorder(t->right); Page 9 of 16

10 The in-order, pre-order, and post-order traversals can be generated by drawing the tree and just walking around it starting from the left of the and ending at the right of it. For each node we note when we are on its left, under it, and on its right. As shown in Figure, the pre-order, inorder, and post-order traversals are generated by visiting each node when we are on the left, under, and right of it respectively. A B K Q C H L X M P NLR visit when at the left of the Node LNR visit when under the Node LRN visit when at the right of the Node A B C Q M H K LX P Q C M B H A L KX P Q M C H B L P XK A Figure shows the three tree traversals for an expression tree. Note that the in-order, pre-order, and post-order traversals generate the expression in infix, prefix, and postfix respectively. - + / A * D * B C E F LNR: A + B * C D / E * F NLR: + A * B C / D * E F LRN: A B C * + D E F * / Page 10 of 16

11 The destructor As shown is Figure, the binary tree destructor uses clear function. As can be seen easily, clear requires a post-order traversal of the tree. The resulting code is given in Figure void BinaryTree<T> :: clear(treenode<t> *t) { if (t!= NULL) { clear(t->left); clear(t->right); delete t; Exercise 1. write the copy constructor 2. write the assignment operator 3. write a member function to count the number of nodes in the tree 4. write a member function to count the leaf nodes 5. write a member function to count the nodes with degree 1 6. write a member function to count nodes with degree 2 7. write a member function to calculate the height of the tree 8. write a member function to make a mirror image of the tree 9. write a member function to determine the presence of a key in the tree. 10. write a function to determine the level of the node containing a given key. Return -1 if the key is not present. 11. write a member function == which returns true if the two trees are equal. 12. write a member function that takes a key and prints the entire subtree ed at the node that contains the key. 13. write a member function that takes a key and prints the entire subtree ed at the sibling of the node that contains the key. 14. write a member function that deletes all the leaf nodes from the tree. Page 11 of 16

12 15. write a member function that deletes all the nodes with degree 1 from the tree. 16. write a member function that takes two keys as input and inserts a node with second key as the left most descendent of the node with the first key if it the first key present in the tree making the new node the first node to be visited in in-order in the tree ed at the node that contains the first key. 17. write a member function that takes two keys as input and inserts a node with second key as the right most descendent of the node with the first key if it the first key present in the tree making the new node the last node to be visited in in-order in the tree ed at the node that contains the first key. Page 12 of 16

13 5.4 Tree iterators Just like the linked-list class, we need tree iterators that would allow us to access each element of the tree in some order so that we can process data according to our specific need. Since, for each node reached through the iterator we process the data in the node and then request for the next node, we cannot use recursion because once we return from that function, we cannot restart the recursion from that node the context (addresses of the all the ancestors stored on to the implicit stack) would have been lost. We would therefore need an iterative solution where, in order to remember the context, an explicit stack needs to be employed. Following this line of thought, an in-order iterator for the binary tree class is developed. The iterator supports the four basic functions create, isdone, begin, next, and getdata and is presented in Figure. class LNRIterator { private: const BinaryTree<T> &tree; TreeNode<T> *current; Stack<TreeNode<T> *> stk; // the associated tree // pointer to the current node // used for storing those // ancestors of current that are // yet to be visited TreeNode<T> * gototheleftmostdescendent(treenode<t> *t); // given a node, go its leftmost descendent // to be used in begin() and next() public: LNRIterator(const BinaryTree<T> &bt):tree(bt), current(null){ bool isdone() {return current == NULL; T getdata() { if (!isdone()) return current->data; else throw ILLEGAL_REFERNCE_EXCEPTION; ; void begin(); // takes current to the first node to be visited void next(); // moves current to the next node in order The constructor, isdone, and getdata are trivial and do not need elaboration. We will therefore only focus on begin and next which are given in Figure. Page 13 of 16

14 TreeNode<T> * LNRIterator<T> :: gototheleftmostdescendent(treenode<t> *t) { TreeNode<T> *temp = t; while(temp->left!= NULL) { stk.push(temp); temp = temp->left; return temp; void LNRIterator<T> :: begin() { stk.clear(); stk.push(null); current = ; if (!= NULL) // if the tree is not empty current = gototheleftmostdescendent(); Begin sets the value of the current to the first node to be visited in order. Starting from the, it gets to the left-most child of the by keeping moving to the left until by a node is reached whose left child is not present. Before moving to the left, address of the node is saved so that it can be used later for visiting the node and then traversing its right subtree. It may be noted that begin also initializes the stack by clearing it of its contents and puts NULL on to it. This will be used to set the value of current to NULL when the iterator goes beyond the last node. After visiting a node, the in-order traversal of the right subtree by moving to its right child and then to the leftmost descendent of the right child and saving the address of the nodes encountered in the process. This is like repeating the process similar to begin for the tree ed at the right child of a node. Once the traversal on the right is complete, this means the entire subtree ed at that node is complete and hence current moves back one step in the hierarchy by popping the address of its ancestor. The process continues until NULL is popped from the stack and assigned to current, indicating end of traversal. The code for the next() operation is given in Figure void LNRIterator<T> :: next() { if (current == NULL) throw ILLEGAL_REFERENCE_EXCEPTION; if (current->right!= NULL) { current = gototheleftmostdescendent(current->right); else current = stk.pop(); Page 14 of 16

15 We can now use this iterator to for our specific purpose as shown below: BinaryTree<int> bintree; // add data to the tree LNRIterator<int> myiterator(bintree); for(myiterator.begin(); myiterator.isdone(); myiterator.next()) cout << getdata(); Exercise: 1. Write pre-order iterator. 2. write post-order iterator. 3. write iterative stack-based in-order traversal 4. write iterative stack-based pre-order traversal 5. write iterative stack-based post-order traversal 6. write a member function of the in-order iterator class to add a new node as the leftmost descendent of the current node. 7. Write a function to delete the leftmost descendent of the current class. Warning: the node to be deleted may have a right child which must be preserved. 8. write a member function of the in-order iterator class to add a new node as the rightmost descendent of the current node. 9. Write a function to delete the rightmost descendent of the current class. Warning: the node to be deleted may have a left child which must be preserved. Page 15 of 16

16 5.5 Level-order traversal Level-order traversal traverses the tree level by level. That is, it traverses all the nodes at level i before moving to nodes at level i+1. Such a traversal is also called depth-first traversal. Traditionally, level-order traversal is performed top-to-bottom and left-to-tight. For example, level-order traversal of the tree of Figure will visit nodes in the following order: A B K C H L X Q M P Level-order traversal can be implemented by using a queue. A node at level i would have its children at level i+1. Therefore, after visiting a node, if its children were added to the queue, then they could be retrieved from the queue and visited in their order of insertion, resulting in levelorder traversal. We start by inserting the node to the queue. Then we remove a node from the queue, visit it and put its children, if any, on the queue. The process continues until there is nothing left on the queue. The code for level-order traversal is presented in Figure void BinaryTree<T> :: levelorder() { if (!= NULL) { TreeNode<T> *t; Queue<TreeNode<T> *> que; que.add(); while(!que.isempty()) { t = que.remove(); visit(t); if (t->left!= NULL) que.add(t->left); if (t->right!= NULL) que.add(t->right); Exercise: 1. Write a function that takes a number as input and prints all the nodes present at that level. 2. Write level-order iterator. 3. Write a recursive function to achieve the task specified in Q. 1 Page 16 of 16

Trees : Part 1. Section 4.1. Theory and Terminology. A Tree? A Tree? Theory and Terminology. Theory and Terminology

Trees : Part 1. Section 4.1. Theory and Terminology. A Tree? A Tree? Theory and Terminology. Theory and Terminology Trees : Part Section. () (2) Preorder, Postorder and Levelorder Traversals Definition: A tree is a connected graph with no cycles Consequences: Between any two vertices, there is exactly one unique path