1 / 26

Trees

Trees. A. B. C. D. E. F. G. H. I. J. K. L. M. Introduction. Figure 5.2 : A sample tree. 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. A. B. D. C. E. F. G. H. J. I.

beulahj
Download Presentation

Trees

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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’)

More Related