Lecture 11: Multiway and (2,4) Trees. Courtesy to Goodrich, Tamassia and Olga Veksler

Transcription

1 Lecture 11: Multiway and (2,4) Trees Courtesy to Goodrich, Tamassia and Olga Veksler Instructor: Yuzhen Xie

2 Outline Multiway Seach Tree: a new type of search trees: for ordered d dictionary ADT Searching in multiway trees (2,4) trees: a special case of multiway trees Height properties p Insertion Deletion 2

3 Review: Binary Search Tree < 6 2 > 1 4 = 8 9 Question: can we generalize binary search trees to hold more than 1 entry per node? Answer: yes, with multiway search tree Why should we care? New type of search tree Smaller height ht (but not necessarily more efficient) i 3

4 Multi-Way Search Tree Multi-way search tree is not binary (more than two children are allowed) Each node can store more than one ordered entries keys between 2 and 6 keys between 6 and 8

5 Multi-Way Search Tree A multi-way search tree is an ordered tree such that Each internal node has at least two children and stores d 11 key-value items (k i, o i ), where d is the number of children For a node with children v 1 v 2 v d storing keys k 1 k 2 k d 1 keys in the subtree of v 1 are less than k 1 keys in the subtree of v i are between k i 1 and k i (i = 2,, d 1) keys in the subtree of v d are greater than k d 1 The leaves store no items and serve as placeholders 5

6 Multi-Way Search Tree For node with children v 1 v 2 v d storing keys k 1 k 2 k d 1 keys in the subtree of v 1 are less than k 1 keys in the subtree of v i are between k i 1 and k i (i = 2,, d 1) keys in the subtree of v d are greater than k d 1 k 1 k 2 k v 1 v 2 v 3 v 4 3 between 2 and 6 between 6 and 8 6

7 Multi-Way Inorder Traversal We can extend the notion of inorder traversal from binary trees to multi-way search trees Namely, we visit item (k i, o i ) of node v between the recursive traversals of the subtrees of v rooted at children v i and v i + 1 An inorder traversal of a multi-way search tree visits the keys in increasing order

8 Multi-Way Searching Similar to search in a binary search tree An internal node with children v 1 v 2 v d and keys k 1 k 2 k d 1 k = k i (i = 1,, d 1): the search terminates successfully k < k 1 : we continue the search in child v 1 k i 1 < k < k i (i = 2,, d 1): we continue the search in child v i k > k d 1 : we continue the search in child v d Reaching an external node terminates the search unsuccessfully Assuming d is a constant independent of number of nodes, examining each node during search takes O(1) ( ) time, thus time to search is proportional to the multiway tree height Example: search for

9 Multi-Way Searching: Another Example Search for key 7 Search terminates at a leaf child, which implies that there is no entry with key 7 in the tree

10 (2,4) Trees A (2,4) tree (also called 2-4 tree or tree) is a multi-way search tree with the following properties Node-Size Property: every internal node has at most four children Depth Property: all the external nodes have the same depth Recall that in a multiway tree, the minimum number of children for an internal node is 2. Thus an internal node can have 2, 3, or 4 children The depth property together th with the requirement that t every internal node has at least 2 children, will guarantee logarithmic height (in the number of entries) for the tree, as we shall see later 10

11 (2,4) Trees Internal node can have 2, 3, or 4 children Depending on the number of children, an internal node of a (2,4) tree is called a 2-node, 3-node or 4- node 11

12 Height of a (2,4) Tree Theorem: A (2,4) tree storing n entries has height O(log n) Proof: Let h be the height of a (2,4) tree with n entries Since each internal node holds at least one entry, n number of internal nodes By depth property, no external nodes at depths i = 0,, h 1 By multiway tree property, each hinternal node has at tleast t2 children, there are at least 2 i entries at depth i = 0,, h 1 and no items at depth h, we have n number of internal nodes h 1 = 2 h 1 Thus, h log (n + 1), and therefore h is O(log n) depth 0 1 # of entries 1 2 h h 1 h 0

13 Other Operations in a (2,4) Tree Thus searching in a (2,4) tree with n items takes O(log n) time Now we have to show how to insert and remove entries in a (2,4) tree while preserving the node-size and the depth properties Insertion into (2,4) tree is easier than into AVL tree Removal is slightly more complicated than the insertion 13

14 Insertion Suppose we need to insert a new entry (k, o) in the (2,4)-tree Always insert at a node only with leaf children (a node at level h-1, where h is the maximum depth of the tree) Suppose we know the correct node v to insert in. put (k, o) ) in the correct place (keys have to stay in order at node v) since the number of entries increased, for the tree to stay a multiway tree, we must add 1 more leaf child to v (in the correct place, after the inserted entry) v insert 30 v v insert 40 v

15 Insertion How to find the correct node v to insert? i.e. inserting in v preserves the multiway tree search order There are 2 cases: Case 1: The key k is not in the tree. Then v is the parent of the leaf reached by searching for k Example: insert v v

16 Insertion Case 2: The key k is already in the tree. Solve it in a way similar to the binary search trees Perform search. When reach node v containing entry with key k i = k, continue search in the left subtree v i (could, equivalently go in the right subtree v i+1 ). Stop when reached the node with only leaf children. Example: insert v v

17 Insertion The procedure on the previous slides preserves: Multiway search tree order Depth property (all external nodes have the same depth) But it may violate the node size property Overflow occurs when a 4-node becomes 5-node (illegal in (2,4)-tree) v v overflow

18 Insertion: Overflow and Split u v u v' v" v 1 v 2 v 3 v 4 v v 5 1 v 2 v 3 v 4 v 5 overflow split We handle an overflow at a 5-node v with a split operation: let v 1 v 5 be the children of v and k 1 k 4 be the keys of v node v is replaced by nodes v' and v" v' is a 3-node with keys k 1 k 2 and children v 1 v 2 v 3 v" is a 2-node with key k 4 and children v 4 v 5 key k 3 is inserted into the parent u of v (a new root may be created) If v was child i of u, v and v become children i and i +1 of u, respectively The overflow may propagate to the parent node u

19 Insertion Example overflow overflow

20 Analysis of Insertion Algorithm insert(k, o) 1. v = search(root, k) while (! v has only external children) v = search(v.childtotheleft(k)) 2. We add the new entry (k, o) at node v 3. while overflow(v) if isroot(v) create a new empty root above v v split(v) search(node, k) returns the node which has entry with key k or, if key k is not in tree, the parent of the leaf reached when searching for k v.childtotheleft(k)) ( returns the child immediately to the left of key k split(v) performs the split on node v and returns the parent of node v Let T be a (2,4) tree with n items Tree T has O(log n) height Step 1 takes O(log n) time because we visit O(log n) nodes Step 2 takes O(1) time Step 3 takes O(log n) time because each split takes O(1) time and we may perform up to O(log n) splits Thus, an insertion in a (2,4) tree takes O(log n) time 20

21 Deletion: Step 1 Like in AVL trees, first ensure that entry that needs to be deleted is at the node with leaf children If an entry is an internal node with no leaf children replace the entry with its inorder successor (or, equivalently, with its inorder predecessor) and delete the latter entry and one leaf Example: to delete key 24, we replace it with 27 (inorder successor)

22 Step 2: Underflow and Transfer Now assume that entry to be deleted is at node v with leaf children Deletion from v can cause an underflow (if v becomes a 1-node) To handle an underflow at node v with parent u, we consider two cases (note that underflow node v has no entries) Case 1: an adjacent sibling w of v is a 3-node or a 4-node Transfer operation: 1. we move a child of w to v 2. we move an entry from u (the entry between w and v) to v 3. we move an entry from w (the entry with key closest to the deleted key in u at step 2) to replace the missing entry of u After a transfer, no new underflow occurs 2 u w v 2 u w 9 v

23 Step 2: Underflow and Fusion Case 2: all adjacent siblings of v are 2-nodes Cannot do transfer in this case, will do fusion Fusion operation: we merge v with an adjacent sibling w and move an entry from u (the entry between w and v) to the merged node v' After a fusion, the underflow may propagate to the parent u If underflow propagates all the way to the root, we simply delete the root in which h case, height ht of the tree decreases by 1 u w v u v'

24 Another Fusion Example u 9 9 delete w 2 v underflow v u 2 9 underflow 2 9

25 Comments on Deletions Either case 1 or case 2 must always hold Let v be the node from which we deleted an entry No underflow before deletion in the tree Thus parent of v must be at least 2-node(but could be also a 3 node or a 4 node) Thus node at which deletion occurs must have at least 1 sibling which is at least a 2-node (but could be also a 3 node or a 4 node) u w v

26 Deletion Example 9 14 delete underflow! transfer 7 14 delete underflow! fusion

27 Deletion Algorithm delete(k) search for key k to locate the deletion node v if v is not internal node with leaf children then swap(entry at v,, entry at inorder successor of (v,k)), v = position of inorder successor of (v,k) Delete the entry with key k from v while underflow(v) if isroot(v) = true make (the only) child of v the new root else if there is a 3-4 node immediate sibling s transfer(v,s) else s = immediate sibling of v v = fusion(v,s) ( ) O(log n) O(log ( n) ) O(1) transfer(v s) O(log n) Inorder successor(v,k) is the smallest entry in the subtree to the right of key k in node v Thus, deleting an item from a (2,4) tree takes O(log n) time Assume fusion(v,s) returns the parent of v 27

28 Analysis of Deletion (repeated) Let T be a (2,4) tree with n items Tree T has O(log n) height In a deletion operation We visit O(log n) nodes to locate the node from which to delete the entry We handle an underflow with a series of O(log n) fusions, followed by at most one transfer Each fusion and transfer takes O(1) time Thus, deleting an item from a (2,4) tree takes O(log n) time 28

29 Implementing a Dictionary Comparison of efficient dictionary implementations Search Insert Delete Notes Hash Table 1 expected 1 expected 1 expected no ordered dictionary methods simple to implement AVL Tree log n worst-case log n worst-case log n worst-case complex to implement (2,4) Tree log n worst-case log n worst-case log n worst-case complex to implement 29

30 AVL vs (2,4) Trees Advantages of (2,4) trees over AVL trees Easier to understand In general, fewer nodes (smaller height) Advantages of AVL trees over (2,4) trees More efficient (by a constant factor, both trees have O(log n) basic operations complexity) Easier to implement ( I think ) Only 1 type of nodes to maintain, as opposed to 23 2,3,4 nodes of f(2 (2,4) tree 30

31 Another Insertion Example insert split split

32 Another Deletion Example 22 delete fusion transfer underflow