Rossella Lau Lecture 8, DCO20105, Semester A, DCO Data structures and algorithms  Lecture 8: Trees  General model of a tree  Binary Tree  Tree representations  Heap and Heap sort  Binary Search Tree: construction and search -- By Rossella Lau

Rossella Lau Lecture 8, DCO20105, Semester A, A reason for Tree  Basic sequential containers do not support efficient processes on all of {insert, delete, search}  vectors: can support efficient search but not insert/delete  list: can support efficient insert/delete but not search Any other structures support efficient processes on all the above operations?  Tree

Rossella Lau Lecture 8, DCO20105, Semester A, Tree  In the most general sense, is a set of vertices, or nodes, and a set of edges, where each edge connects a pair of distinct nodes, such that there is one and only one connecting path on these edges between any pair of nodes.  A tree in the above sense is called a free tree  By picking up a distinguished node, denoting it as a root, as the entrance of the tree, a tree can be represented as an oriented tree  A free tree may have numerous oriented trees corresponding to a given free tree

Rossella Lau Lecture 8, DCO20105, Semester A, Different orientations of a tree A B D C E F A CD EF B A CD EF B A CBD EF

Rossella Lau Lecture 8, DCO20105, Semester A, Binary Tree A binary tree can be empty or partitioned into three disjointed subsets: 1. A single element called the root of the tree 2. A left sub-tree, which is a binary tree, of itself 3. A right sub-tree, which is a binary tree, of itself Tree or binary tree’s definition is a recursive definition and operations on trees are usually in a recursive manner

Rossella Lau Lecture 8, DCO20105, Semester A, Notations of a binary tree A C F HI B DE G  A is the root of the tree  A is the parent of B and C (B is the parent of D and E, …)  B is a left child of A  C is a right child of A  A or B is an ancestor of E  E or B is a descendant of A  B and C are siblings  D, G, H, I are leaves of the tree  The level of A is 0, the level of B is 1, …, the level of G is 3  Depth = max{ level of leaves} = 3

Rossella Lau Lecture 8, DCO20105, Semester A, Structures that are not binary trees A C F I B DE GH  All of these trees contain a tree which is not a sub-tree of itself  There is more than one path connecting two of the nodes A C F B DE G A C F B DE G HI

Rossella Lau Lecture 8, DCO20105, Semester A, Traversing a binary tree  To pass through a binary tree and enumerate each of its nodes once  To enumerate, e.g., to print the contents of each node, to update the contents of each node  When a node is enumerated, it is visited There are, usually, three ways to traverse a binary tree  Preorder (depth-first order)  Inorder (symmetric order)  Postorder

Rossella Lau Lecture 8, DCO20105, Semester A, The algorithms for traversing a binary tree Preorder: 1.Visit the root 2.Traverse the left sub-tree in preorder sequence 3.Traverse the right sub-tree in preorder sequence Inorder: 1.Traverse the left sub-tree in inorder sequence 2.Visit the root 3.Traverse the right sub-tree in inorder sequence Postorder: 1.Traverse the left sub-tree in postorder sequence 2.Traverse the right sub-tree in postorder sequence 3.Visit the root

Rossella Lau Lecture 8, DCO20105, Semester A, Examples of traversing a binary tree For the binary tree on page 6  Preorder:  Inorder:  Postorder:

Rossella Lau Lecture 8, DCO20105, Semester A, Representations of Binary Tree  Static: Vector representation  Dynamic: Pointer (Node) representation

Rossella Lau Lecture 8, DCO20105, Semester A, Complete binary trees  A Complete binary tree of depth d:  all of whose leaves are at level d  all of non-leaf (internal) nodes have exactly two children  A binary tree of depth d is an almost complete binary tree if: 1. Any node n at level from 0 to d-2 has two children 2. For each node n in the tree with a right descendant at level d  n must have a left child and  every left descendant of n is either a leaf at level d or has two children

Rossella Lau Lecture 8, DCO20105, Semester A, A complete binary tree of depth 3 B DE A HIJK C FG LMNO

Rossella Lau Lecture 8, DCO20105, Semester A, Examples of almost complete binary trees B DE A HI C FG B DE A HI C FG J  Is this an almost complete binary tree? B DE A HI C FG J

Rossella Lau Lecture 8, DCO20105, Semester A, Density of a tree  A complete binary tree has the highest density: number of nodes: 2 d  A tree with nodes which all have a single child has the lowest density: number of nodes: d+1  A tree with not many nodes is called sparse  Give number of nodes n, a tree can be with a depth of n-1 to log2 (n+1) - 1

Rossella Lau Lecture 8, DCO20105, Semester A, Implicit array representation of a binary tree  For each almost complete binary tree, we can label each node from 0 to n, where n < (2 d+1 - 1) B DE A HI C FG J  The label is the subscript of an array  The content of a numbered node can be stored in the corresponding position of an array ABCDIEHFGJ

Rossella Lau Lecture 8, DCO20105, Semester A, Extensions to almost complete BT B A C DE FG I H J KL M B A C DE FG I H J KL M ABCDE FG HIJKLM For trees that are not a complete binary tree, we may add null nodes to make the trees become almost complete

Rossella Lau Lecture 8, DCO20105, Semester A, Some operations on vector representation  Some basic binary tree operations can be easily implemented:  vector bt;  left_child(node): 2 * node + 1  right_child(node): 2 * (node + 1)  parent(node): (node – 1) / 2 when node > 0  data(node): bt[node]  For efficient calculation of parent and children, representation may start the root from subscript at 1 instead of 0  left_child(node): 2 * node (equivalent to node<<1 )  right_child((node): left_child + 1  parent(node): node / 2 (equivalent to node>>1 )  the calculation can be simplified to bit-shift operations

Rossella Lau Lecture 8, DCO20105, Semester A, Exercises on implicit representation  Ford’s written exercises: 14:11a, 12c

Rossella Lau Lecture 8, DCO20105, Semester A, An application of array representation: Heap  A heap is an almost complete binary tree in which each node is less than or equal to its parent  Since it is an almost complete binary tree, its implementation uses implicit array representation  The common use of a heap is as a priority queue  A sample of a heap

Rossella Lau Lecture 8, DCO20105, Semester A, Heap insert  To insert the item as the last leaf in the tree then shift it up whenever it is larger than its parent  E.g., Adding 92 to the previous heap

Rossella Lau Lecture 8, DCO20105, Semester A, Heap delete  To remove the maximum from the heap: 1. Swap the root (maximum) with the last element in the array (the last node in the tree)  the heap is reduced by one element 2. Shift the new root down whenever it is less than its larger child within the reduced heap

Rossella Lau Lecture 8, DCO20105, Semester A, Exercise on heap  Ford’s written exercises: 14:19b

Rossella Lau Lecture 8, DCO20105, Semester A, Heap sort  A binary tree can be represented by a vector; a list of data in a vector can also be treated as an almost complete binary tree!  Heap sort makes use of this feature to construct data on a vector into a heap then sort data in order  It is a kind of selection sort  Each time it finds the largest from a list (the heap) then places it to the last position of the list  The process continues the “selection” on the sub-lists starting from the first elements which are not in the proper positions yet.

Rossella Lau Lecture 8, DCO20105, Semester A, Heap sort method 1  1 st phase: Construction of a heap  it inserts elements to the heap one by one ()  2 nd phase: Selection sort 1. remove the maximum from the heap and replace it to the last (the heap is reduced in the first n-1 nodes) 2. process continues until reduced heap becomes a single node

Rossella Lau Lecture 8, DCO20105, Semester A, An example of heap sort (method 1)  Input stream:  Then insert data one by one into the heap:

Rossella Lau Lecture 8, DCO20105, Semester A, Phase II of heap sort ……

Rossella Lau Lecture 8, DCO20105, Semester A, Heapsort (method 2)  Instead of inserting data one by one, it converts the tree to a heap in the first phase makeHeap() in Ford: Iteratively applying the heap condition to each internal node (sub-trees) starting at the last and working up to the root  Then it applies the second phase of method 1

Rossella Lau Lecture 8, DCO20105, Semester A, Phase I of method

Rossella Lau Lecture 8, DCO20105, Semester A, Performance of heap sort  For each insertion, it takes O(logn) because the process is on an almost complete binary tree  For n elements, it takes O(nlogn) even for worst case  Experiments show that heapsort doubles the time of quicksort but out performs quicksort in the worst case since the process keeps working on an almost complete binary tree (level at most log(n+1)).

Rossella Lau Lecture 8, DCO20105, Semester A, Dynamic pointer representation  Reference program: BST.h: use two classes: BNode and BTree template class BNode { T item; BNode *left; BNode *right; //end of data member ……} template class BTree { BNode *root; size_t countNodes; //end of data member …… }

Rossella Lau Lecture 8, DCO20105, Semester A, Implementation of inorder traversal template void BTree ::inOrder(BNode const *bnode) const { if (bnode->left) inOrder(bnode->left); cout item << “ “; if (bnode->right) inOrder(bnode->right); } template void BTree ::inOrder() const { if ( root ) inOrder(root); else cout << “Empty tree\n”; }

Rossella Lau Lecture 8, DCO20105, Semester A, Pretty tree  In order to make a tree visible, we may imagine the tree with a 90 degree left rotation, then we have a special printing method: a reversed inorder traversal with nodes printed according to their levels void prettyTree (BNode const *bnode, size_t const level) const { if (bnode->right) prettyTree(bnode->right, level + 1); // make space for different levels for (size_t i=0; i<level; i++) cout << “ “; cout item << endl; if (bnode->left) prettyTree(bnode->left, level + 1); } void prettyTree () { if (root) pretty_tree(root, 0); else …… }

Rossella Lau Lecture 8, DCO20105, Semester A, Binary Search Tree (BST)  A BST is a binary tree in which all the key values stored in the left descendents of a node are less than the key value of the node, and all the key values stored in the right descendants of a node are greater than the key value of the node. E.g.,

Rossella Lau Lecture 8, DCO20105, Semester A, Dynamic representation for a BST  Same as a Binary Tree; sample program: BST.h template class BSTNode { T item; BSTNode *left; BSTNode *right; //end of data member ……} Template class BSTree { BSTNode *root; size_t countNodes; //end of data member …… }

Rossella Lau Lecture 8, DCO20105, Semester A, The algorithm for searching on a BST  The searching can use a recursive approach. BSTNode * BSTree ::search (BSTNode const *node, T const& target) const { if ( target == node->item ) return node; if ( target item ) return node->left ? search(node->left, target) : 0; else return node->right? search(node->right, target): 0; } BSTNode * BSTree ::search (T const& target) const { return root ? search(root, target) : 0; }

Rossella Lau Lecture 8, DCO20105, Semester A, The iterative version for searching on a BST  However, it is also quite easy to convert the recursive algorithm to a non-recursive(iterative) one since it only involves "going down" the tree. BSTNode * BSTree ::search(T const& target) const { BSTNode *cur = root; while (cur) { if (target == cur->item) return cur; if (target item;) cur = cur->left; else cur = crr->right; } return 0; }

Rossella Lau Lecture 8, DCO20105, Semester A, A better way to return the result: find()  Searching usually follows the operations of insert or delete but the traditional search returns  a null pointer when a new item is required to insert; i.e., the insert has to find the proper position to insert the item, again!  the node for deletion which requires checking if the node is on the right hand side or the left hand side of its parent, again!  With the reference supported in C++, we can write a find() which is similar the one in List.h in Lecture 4 for efficient insert() and remove() with one single search operation even if these operations require a search to make sure the node does not exist or does exist  Node *& means a reference of pointer that can be interpreted as the reference of the location where the pointer stores. From another view, if the name is on the right hand side of an expression, it refers to the value of the pointer, i.e., the node pointed to by the pointer; if the name is on the left hand side, it refers to the location storing the pointer; or the "parent" of the node! Assigning new values to the name means to change its "child"!

Rossella Lau Lecture 8, DCO20105, Semester A, The implementation of find() BSTNode *& find (T const & target) { if ( !root || target == root->item ) return root; BSTNode * par = root; // parent of current node while( 1 ) { if ( target item ) if (!par->left || target == par->left->item) return par->left; else par = par->left; else if (!par->right || target == par->right->item) return par->right; else par = par->right; }}

Rossella Lau Lecture 8, DCO20105, Semester A, Insert an item with find()  To insert an item involves searching for the correct place and usually, a BST assumes no duplication, then attach the new node to the target found by find()  Add an additional function attach() to BSTree bool attach( BSTNode *& nodeRef, T const & x ) { nodeRef = new BSTNode ( x ); return nodeRef;} bool insert(T const & target) { BSTNode *& curRef ( find ( target ) ); if ( !curRef ) return attach(curRef, target); else return false; // duplication }

Rossella Lau Lecture 8, DCO20105, Semester A, Construction of the BST using insert() Input sequence: 50, 28, 40, 75, 90, 22, 35, 95, 87  An online animation is also available at: l

Rossella Lau Lecture 8, DCO20105, Semester A, More exercises on BST  Ford’s exercises: 10:20, 22

Rossella Lau Lecture 8, DCO20105, Semester A, Complexity considerations  If the binary tree is constructed in a random order, the levels of the left sub-tree and right sub-tree of the resulting tree may be similar and each later search process is similar to a binary search in an array  Therefore, the optimal complexity for searching on a BST is about O(log 2 n)  However, if the input sequence for the BST is in sequential order, it may result in the tree on the next page. The complexity of find() becomes O(n)  Therefore, the complexity of the search on a BST is from O(log 2 n) to O(n).

Rossella Lau Lecture 8, DCO20105, Semester A, The worst case of searching on a BST  Input sequence: 22, 28, 35, 40, 50, 75, 87, 90,

Rossella Lau Lecture 8, DCO20105, Semester A, Complexity for insert()  As the logic of insert() is find() + attach()  If there is a fast memory allocation method, the running time of attach() is O(1)  insert() is similar to find(), insert() has the same complexity as find()

Rossella Lau Lecture 8, DCO20105, Semester A, Summary  A binary tree is a typical recursive structure and has three parts: root, left and right sub-trees  A binary tree is used to being stored in node representation  Sometimes, it is also efficient to store a binary tree in implicit array (vector) representation and its typical applications are heap and heap sort which is quite an efficient sorting algorithm for all cases  There are three usual ways to traverse a binary tree: preorder, inorder, and postorder  The binary search tree (BST) keeps smaller values on the left side of a node and larger values on the right  The optimal complexity for insert/search of a BST is O(log 2 n)

Rossella Lau Lecture 8, DCO20105, Semester A, Reference  Ford: ,  Data Structures and Algorithms in C++ by Michael T. Goodrich, Roberto Tamassia, David M. Mount : Chapter 6,8  Example programs: BST.h, testBST.cpp -- END --