Exploring Binary Trees: Structures, Properties, and Operations

1. Trees

2. A B C D E F G H I J K L M Introduction Figure 5.2 : A sample tree

3. A 0 B F 0 C G 0 D I J 0 E K L 0 H M 0 List Representation Figure 5.3 : List representation of the tree of Figure 5.2

4. A B D C E F G H J I K L M Left child-right sibling representation • 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)

5. A B A C E B B K D F G L H M I J • 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

6. A A B B C C D G E F D H I E Binary Trees Figure 5.10 : Skewed and complete binary trees

7. 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 • A full binary tree of depth k • a binary tree of depth k having 2k-1 nodes, k≥ 0

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

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

10. data Figure 5.13 : Node representations

11. A B C D G E F H I Figure 5.14 : Linked representation for the binary trees of Figure 5.10

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

13. Constructing the original tree from inorder/preorder • Constructing the original tree from inorder/postorder • Constructing the original tree from preorder/postorder

14. 14 2 11 30 10 9 12 7 4 7 25 21 6 20 3 83 10 10 8 8 6 6 50 5 5.6 Heaps(Cont’) Figure 5.24 : Max heaps Figure 5.25 : Min heaps

15. 5.6.3 Insertion into Max Heap Examples 20 15 2 10 14 20 21 15 15 20 10 10 14 2 14 2 Heaps Figure 5.26 : Insertion into a max heap

16. Heaps(Cont’) • Implementation • need to move from child to parent • heap is complete binary tree • use formula-based representation • Lemma 5.4 : parent(i) is at if i≠ 1 • Complexity is O(log n)

17. Heaps(Cont’) template <class Type> void MaxHeap<Type>::Insert(const Element<Type> &x) // insert x into the max heap { if (n = = MaxSize) {HeapFull(); return;} n++; for (int i = n; 1; ) { if (i = = 1) break; // at root if (x.key <= heap[i/2].key) break; // move from parent to i heap[i] = heap[i/2]; i /= 2; } heap[i] = x; } Program 5.18 : Insertion into a max heap

18. 15 15 20 14 2 14 10 6 10 Heaps(Cont’) Deletion from Max Heap • Example Figure 5.27 : Deletion from a heap

19. Heaps(Cont’) template <class Type> Element<Type> *MaxHeap<Type>::DeleteMax(Element<Type> &x) // Delete from the max heap { if (!n) {HeapEmpty(); return 0;} x = heap[1]; Element<Type> k = heap[n]; n--; for (int i = 1, j = 2; j <= n; ) { if (j<n) if (heap[j].key < heap[j+1].key) j++; // j points to the larger child if (k.key >= heap[j].key) break; heap[i] = heap[j]; // move child up i = j; j *= 2; // move i and j down } heap[i] = k; return &x; } Program 5.19 : Deletion from a max heap

20. Binary Search Trees Definition • Definition • binary tree which may be empty • if not empty (1) every element has a distinct key (2) keys in left subtree < root key (3) keys in right subtree > root key (4) left and right subtrees are also binary search trees

21. 20 30 15 25 5 40 12 22 2 10 Binary Search Trees(Cont’) 60 70 65 80 Figure 5.28 : Binary trees

22. Binary Search Trees(Cont’) Searching Binary Search Tree • Recursive search by key value • definition of binary search tree is recursive • key(element) = x • x=root key : element=root • x<root key : search left subtree • x>root key : search right subtree • Complexity : O(h)

23. 30 30 5 40 5 40 2 80 2 80 35 Binary Search Trees(Cont’) Insertion into Binary Search Tree • New element x • search x in the tree • success : x is in the tree • fail : insert x at the point the search terminated Figure 5.29 : Inserting into a binary search tree

24. Binary Search Trees(Cont’) template <class Type> Boolean BST<Type>::Insert(const Element<Type> &x) // Insert x into the binary search tree { // Search for x.key, q is parent of p BstNode<Type> *p = root; BstNode<Type> *q = 0; while(p) { q = p; if (x.key = = p->data.key) return FALSE; // x.key is already in tree if (x.key < p->data.key) p = p->LeftChild; else p = p->RightChild; } // Perform insertion p = new BstNode<Type>; p->LeftChild = p->RightChild = 0; p->data = x; if (!root) root = p; else if (x.key < q->data.key) q->LeftChild = p; else q->RightChild = p; return TRUE; }

25. Binary Search Trees(Cont’) Deletion from Binary Search Tree • Leaf node • corresponding child field of its parent is set to 0 • the node is disposed • Nonleaf node with one child • the node is disposed • child takes the place of the node • Nonleaf node with two children • node is replaced by either • the largest node in its left subtree • the smallest node in its right subtree • delete the replacing node from the subtree

26. Binary Search Trees(Cont’)