Chapter 5. TREES

1. Chapter 5. TREES Horowitz, Sahni, and Anderson-Freed Fundamentals of Data Structures in C, 2nd Edition Computer Science Press, 2008 Fall 2009 Course, Sungkyunkwan University Hyunseung Choo choo@ece.skku.ac.kr

2. Trees

3. Trees • Introduction • Def) a tree is a finite set of one or more nodes such that 1) there is a special node (root) 2) remaining nodes are partitioned into n  0 disjoint trees T1,T2,···,Tn where each of these is a tree; we call each Ti subtree of the root • acyclic graph : contain no cycle • hierarchical structure

4. A B C D E F G H I J K L M Trees Level 1 2 3 4

5. Trees • Terminology • degree of a node: • the number of subtrees of node • degree of a tree: the maximum • degree of the nodes in the tree • leaf(terminal) node: • a node with degree zero (K, L, F, G, M, I, J) • internal(non-terminal) node: • node with degree one or more (A, B, C, D, E, H)

6. Trees • parent: a node that has subtrees • child: a root of the subtrees • sibling: child nodes of the same parent • ancestor: all the nodes along the path from the root to the node • descendant: all the nodes that are in its subtrees • level: level of node’s parent + 1 (level of the root node is 1) • depth (or height) of a tree: the maximum level of any node in the tree

7. Trees • Representation of trees • list representation • the information in the root node comes first • followed by a list of the subtrees of that node (eg) (A(B(E(K,L),F),C(G),D(H(M),I,J))) • representation of a tree in memory where n is the degree of the tree data link 1 link 2 · · · link n

8. data left child right sibling Trees • Representation of trees • left-child right-sibling representation • nodes of a fixed size • easier to work • two link/pointer fields per node • left-child right-sibling node structure

9. A B C D E F G H I J K L M Trees • left-child right-sibling representation of a tree

10. Trees • Representation of trees • representation as a degree two tree • simply rotate the left-child right-sibling tree clockwise by 45 degrees • two children • left child and right child • degree 2 • binary tree

11. A B E C K F G D L H M I J Trees • left-child right-child tree representation of a tree

12. A A A B B B A A A B B C B C C Trees • tree representations tree left child-right sibling tree binary tree tree left child-right sibling tree binary tree

13. Binary Trees

14. A A B B Binary Trees • Def) a binary tree is a finite set of nodes such that 1) empty or 2) consists of root node and two disjoint binary trees, called, left subtree and right subtree • two different binary trees

15. Binary Trees • Properties of binary trees • difference between a binary tree and a tree • may have empty node • the order of subtrees are important • a binary tree is not a subset of a tree • maximum number of nodes in a BT 2k-1 where k: depth of the tree • relationship between the number of leaf nodes(n0) and the number of nodes with degree 2(n2) n0 = n2 + 1

16. Binary Trees • Special types of binary trees • skewed binary tree • full binary tree (of depth k) • def) a binary tree of depth k(³0) having 2k - 1 nodes • complete binary tree • def) a binary tree with n nodes that correspond to the nodes numbered from 1 to n in the full binary tree of depth k

17. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Binary Trees • full binary tree of depth 4 with sequential node numbers

18. A A B B C C D E F G D H I E Binary Trees • skewed and complete binary trees skewed binary tree complete binary tree

19. Binary Trees • Binary tree representation • array representation • sequential representations • determine the locations of the parent, left child, and right child of any node i in the binary tree 1) parent(i) is at i/2 if i ¹ 1 if i = 1, no parent 2) left_child(i) is at 2·i if 2in 3) right_child(i) is at 2·i + 1 if 2·i + 1  n

20. [1] A [2] B [3] - [1] A [4] C [2] B [5] - [3] C [6] - [4] D [7] - [5] E [8] D [6] F [9] - [7] G · · [8] H · · [9] I · · [16] E Binary Trees • array representation of binary trees skew binary tree complete binary tree

21. Binary Trees • Problems of array representation • inefficient storage utilization S(n) = 2k-1 where k: depth of binary tree ideal for complete binary trees • hard to insert/delete

22. data left_child data right_child left_child right_child Binary Trees • Linked representation • each node has three fields left_child, data, and right_child typedef struct node *tree_ptr; typedef struct node { int data; tree_ptr left_child, right_child; }; • node representation for binary trees

23. root A NULL root A B NULL B C C NULL D E F G NULL NULL NULL NULL NULL NULL D NULL H I NULL NULL NULL NULL E NULL NULL Binary Trees • linked representation for the binary trees skewed binary tree complete binary tree

24. data NULL NULL parent parent left_child data right_child data left_child right_child Binary Trees • leaf node’s link fields contain null pointer • add a fourth field, parent, to know the parent of random nodes leaf node

25. Binary Trees • Tree representation • each node (in a tree) has variable sized nodes • hard to represent it by using array • use linked list need k link fields per node where k: degree of tree • two types of link: non-null links and null links • number of non-null links: n-1 • number of null links: n·k - (n-1)

26. Binary Trees • Convert a tree into a binary tree 1) (parent,child1,child2,...,childk)  (parent,leftmost-child,next-right-sibling)  left-child right-sibling representation 2) simply rotate the left-child right-sibling tree clockwise by 45 degrees • right field of root node always have null link • null links: approximately 50% • depth increased

27. A B C D A B E F G E C A F D G B C D E F G Binary Trees tree binary tree left child-right sibling tree

28. Binary Tree Traversal and Other Operations

29. Binary Tree Traversals • visit each node in the tree exactly once • produce a linear order for the information in a tree • what order? • inorder: LVR (Left Visit Right) • preorder: VLR (Visit Left Right) • postorder: LRV (Left Right Visit) • N.B. • correspondence between these traversals and producing the infix, postfix, and prefix forms of expressions

30. 1 + 2 17 * E 18 19 3 14 * D 15 16 4 11 / C 12 13 5 8 A B 6 7 9 10 Binary Tree Traversals • binary tree with arithmetic expression A / B * C * D + E (infix form)

31. Binary Tree Traversals • Inorder traversal void inorder(tree_ptr ptr) { if(ptr) { inorder(ptr->left_child); printf(“%d”,ptr->data); inorder(ptr->right_child); } } • inorder is invoked 19 times for the complete traversal: 19 nodes • output: A/B*C*D+E • corresponds to the infix form

32. Binary Tree Traversals • trace of inorder

33. Binary Tree Traversals • Preorder traversal void preorder(tree_ptr ptr) { if(ptr) { printf(“%d”, ptr->data); preorder(ptr->left_child); preorder(ptr->right_child); } } • output in the order: +**/ABCDE • correspond to the prefix form

34. Binary Tree Traversals • Postorder traversal void postorder(tree_ptr ptr) { if (ptr) { postorder(ptr->left_child); postorder(ptr->right_child); printf(“%d”, ptr->data); } } • output in the order: AB/C*D*E+ • correspond to the postfix form

35. Binary Tree Traversals • Iterative inorder traversal • Recursion • call itself directly or indirectly • simple, compact expression: good readability • don’t need to know implementation details • much storage: multiple activations exist internally • slow execution speed • applications: factorial, fibonacci number, tree traversal, binary search, tower of Hanoi, quick sort, LISP structure

36. Binary Tree Traversals void iter_inorder(tree_ptr node) { int top = -1; tree_ptr stack[MAX_STACK_SIZE]; while (1) { while (node) { push(&top, node); node = node->left_child; } node = pop(&top); if (!node) break; printf(“%d”, node->data); node = node->right_child; } } • iterative inorder traversal

37. Binary Tree Traversals • every node of the tree is placed on and removed from the stack exactly once • time complexity: O(n) where n: the number of nodes in the tree • space complexity: stack size O(n) where n: worst case depth of the tree (case of skewed binary tree)

38. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Binary Tree Traversals • Level order traversal • traversal by using queue(FIFO) • output in the order: 123456789•••15 for previous example: +*E*D/CAB

39. Binary Tree Traversals void level_order(tree_ptr ptr) { int front = rear = 0; tree_ptr queue[MAX_QUEUE_SIZE]; if (!ptr) return; addq(front,&rear,ptr); while (1) { ptr = deleteq(&front, rear); if (ptr) { printf(“%d”, ptr->data); if (ptr->left_child) addq(front,&rear,ptr->left_child); if (ptr->right_child) addq(front,&rear,ptr->right_child); } else break; } }

40. Additional Binary Tree Operations • Copying binary trees • modified version of postorder tree_ptr copy(tree_ptr original) { tree_ptr temp; if (original) { temp = (tree_ptr)malloc(sizeof(node)); if (IS_FULL(temp)) exit(1); temp->left_child = copy(original->left_child); temp->right_child = copy(original->right_child); temp->data = original->data; return temp; } return NULL; }

41. Additional Binary Tree Operations • Testing for equality of binary trees • modified version of preorder int equal(tree_ptr first,tree_ptr second) { return ((!first && !second) || (first && second && (first->data == second->data) && equal(first->left_child, second->left_child) && equal(first->right_child, second->right_child)); }

42. Heaps

43. Heaps • def) max(min) tree: a tree in which the key value in each node is no smaller(larger) than key values in its children (if any) • def) max(min) heap: a complete binary tree that is also a max(min) tree • the root of a max(min) tree contains the largest(smallest) key in the tree

44. Heaps • Representation of max(min) heaps • array representation because heap is a complete binary tree • simple addressing scheme for parent, left, and right children #define MAX_ELEMENTS 200 #define HEAP_FULL(n) (n == MAX_ELEMENTS - 1) #define HEAP_EMPTY(n) (!n) typedef struct { int key; /* other field */ } element; element heap[MAX_ELEMENTS]; int n = 0;

45. [1] 14 [2] [3] 12 7 [4] [5] [6] 10 8 6 [1] [1] 30 9 [2] [2] [3] 25 6 3 [4] 5 Heaps • sample max heaps

46. [1] 2 [2] [3] 7 4 [4] [5] [6] 10 8 6 [1] [1] 11 10 [2] [2] [3] 21 20 83 [4] 50 Heaps • sample min heaps

47. Priority queues • deletion: deletes the element with the highest (or the lowest) priority • insertion: insert an element with arbitrary priority into a priority queue at any time (ex) job scheduling of OS

48. [1] [1] 20 20 [2] [3] [2] [3] 15 2 15 2 [4] [5] [4] [5] [6] 14 10 14 10 [1] [1] 20 21 [2] [3] [2] [3] 15 5 15 20 [4] [5] [6] [4] [5] [6] 14 10 2 14 10 6 Heaps (a) heap before insertion (b) initial location of new node (c) insert 5 into heap (a) (d) inset 21 into heap (a)

49. Heaps • select the initial location for the node to be inserted  bottommost-rightmost leaf node • insert a new key value • adjust key value from leaf to root parent position: floor(i/2) • time complexity : O(depth of tree)  O(log2n)

50. Heaps void insert_max_heap(element item, int *n) { int i; if (HEAP_FULL(*n)) { fprintf(stderr,”The heap is full. \n”); exit(1); } i = ++(*n); while ((i!=1) && (item.key > heap[i/2].key)) { heap[i] = heap[i/2]; i /= 2; } heap[i] = item; } • insertion into a max heap