(2,4) Trees Goodrich, Tamassia. (2,4) Trees 1

Transcription

1 (2,4) Trees (2,4) Trees 1

2 Multi-Way Search Tree ( 9.4.1) A multi-way search tree is an ordered tree such that Each internal node has at least two children and stores d 1 key-element 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 (2,4) Trees 2

3 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 (2,4) Trees 3

4 Multi-Way Searching Similar to search in a binary search tree A each 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 Example: search for (2,4) Trees 4

5 (2,4) Trees ( 9.4.2) A (2,4) tree (also called 2-4 tree or tree) is a multi-way search 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 Depending on the number of children, an internal node of a (2,4) tree is called a 2-node, 3-node or 4-node (2,4) Trees 5

6 Height of a (2,4) Tree Proof idea: Show there are not enough nodes to grow higher than O(log n) high Theorem: A (2,4) tree storing n items has height O(log n) Proof: Let h be the height of a (2,4) tree with n items Since there are at least 2 i items at depth i = 0,, h 1 and no items at depth h, we have n h 1 = 2 h 1 Thus, h log (n + 1) Searching in a (2,4) tree with n items takes O(log n) time depth 0 1 h 1 h items h 1 0 (2,4) Trees 6

7 Insertion We insert a new item (k, o) at the parent v of the leaf reached by searching for k We preserve the depth property but We may cause an overflow (i.e., node v may become a 5-node) Example: inserting key 30 causes an overflow v v (2,4) Trees 7

8 Overflow and 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 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) The overflow may propagate to the parent node u u v u v' 35 v" v 1 v 2 v 3 v 4 v 5 v 1 v 2 v 3 v 4 v 5 (2,4) Trees 8

9 Analysis of Insertion Algorithm insert(k, o) 1. We search for key k to locate the insertion node v 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) Analysis: Insertion can be done by running down the tree and handling overflow on the way up so O(log n) 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 perform O(log n) splits Thus, an insertion in a (2,4) tree takes O(log n) time (2,4) Trees 9

10 Deletion We reduce deletion of an entry to the case where the item is at the node with leaf children Otherwise, we replace the entry with its inorder successor (or, equivalently, with its inorder predecessor) and delete the latter entry Example: to delete key 24, we replace it with 27 (inorder successor) (2,4) Trees 10

11 Underflow and Fusion Deleting an entry from a node v may cause an underflow, where node v becomes a 1-node with one child and no keys To handle an underflow at node v with parent u, we consider two cases Case 1: the adjacent siblings of v are 2-nodes Fusion operation: we merge v with an adjacent sibling w and move an entry from u to the merged node v' After a fusion, the underflow may propagate to the parent u u 9 14 u w v v' (2,4) Trees 11

12 Underflow and Transfer To handle an underflow at node v with parent u, we consider two cases Case 2: 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 item from u to v 3. we move an item from w to u After a transfer, no underflow occurs 2 u w v u 4 8 w v (2,4) Trees 12

13 Analysis of Deletion Analysis: Deletion can be done by running down the tree and handling underflow on the way up so O(log n) 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 (2,4) Trees 13

14 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 Skip List log n high prob. log n high prob. log n high prob. randomized insertion simple to implement (2,4) Tree log n worst-case log n worst-case log n worst-case complex to implement (2,4) Trees 14

15 B+ Trees (supplementary by: Louis Nel A multi-way search tree used as an index for a database (like a card catalog for a library). One card catalog orders books by author, by subject etc. Creates the illusion that the books are stored certain order, even though they are physically stored in another (2,4) Trees 15

16 Disk Based Search Tree B+ trees use a multi-way search tree to maintain indices and to try and keep the trees balanced. Similar to 2-4 trees except many pointers per node (up to 1000). Could call it a tree. Reason: each node of the tree is a disk block. In databases the number of disk block reads determines the performance of the database. (2,4) Trees 16

17 B+ Tree (n = 3 pointers) <= Brighton > Brighton Redwood Round Hill Brighton 217 Green 750 Downtown 101 Johnson 500 Downtown 110 Peterson Smith Hayes Williams Lyle 700 Redwood 222 Lindsay 700 Round Hill 305 Turner 350 (2,4) Trees 17

18 B+ Tree (n = 5 pointers) Brighton Downtown Redwood Round Hill Brighton 217 Green 750 Downtown 101 Johnson 500 Downtown 110 Peterson Smith Hayes Williams Lyle 700 Redwood 222 Lindsay 700 Round Hill 305 Turner 350 (2,4) Trees 18

19 Anatomy of a B+ Tree (n pointers) Redwood root node can be < half full node: must be at least half full Brighton Redwood Round Hill leaf node between (n-1)/2 and n-1 key values leaf chaining pointers allow sequential access Good size for n? -size of a disk block Leaf nodes form a dense search key index Leaf node contains search key values K1,...,Kn-1 in sorted order and P1,...,Pn pointers Leaf node key values don t overlap (2,4) Trees 19

20 B+ Tree Internal Node P1 K1 P2... Pi Ki Pi+1... Pn-1 Kn-1 Pn X <= K1 Ki-1 < X <= Ki Kn-2 <X <= Kn-1 X > Kn Each internal node (except root) has at least ceiling( n/2 ) pointers (2,4) Trees 20

21 B+ Tree Leaf Node P1 K1 P2... Pi Ki Pi+1... Pn-1 Kn-1 Pn next leaf node Data pointer (to data block or bucket of pointers) data pointer data pointer Each leaf node has at least floor( n/2 ) pointers All leaf nodes are at the same level in the tree (2,4) Trees 21

22 Processing a Search Query To search for data using a B+ tree, follow pointers from root node to leaf node according to search key value. Search path length <= ( K log n/2 ) for at set of search key values K (quite short!) (2,4) Trees 22

23 B+ Trees B+ trees are kept balanced, paths from root to leaf is always the same Insertions and deletions, therefore, require splitting and merging of nodes to ensure that the tree remains balanced (Similar to 2-4 trees) (2,4) Trees 23

24 Insertions and Deletions Brighton Brighton Redwood Round Hill Insert tuple < Bolton,... > (2,4) Trees 24

25 Insertions and Deletions Brighton Bolton Brighton Redwood Round Hill Insert tuple < Aspen,... > (2,4) Trees 25

26 Insertions and Deletions Bolton Brighton Aspen Bolton Brighton Redwood Round Hill Inserting tuple < Aspen,... > requires a new leaf node Note the internal node must also be updated Next delete tuple < Brighton,... > (2,4) Trees 26

27 Insertions and Deletions Bolton Brighton Aspen Bolton Brighton Redwood Round Hill Delete tuple < Brighton,... > (2,4) Trees 27

28 Insertions and Deletions Bolton Aspen Bolton Redwood Round Hill Delete tuple < Brighton,... > Next delete <,... > (2,4) Trees 28

29 Insertions and Deletions Bolton Aspen Bolton Redwood Round Hill delete <,... > Notice internal node will have too few pointers when the leaf node is removed (2,4) Trees 29

30 Insertions and Deletions Bolton Redwood Aspen Bolton Redwood Round Hill delete <,... > (2,4) Trees 30

31 Insertions and Deletions Bolton Aspen Bolton Redwood Round Hill delete <,... > Alternatively, we can notice the combining the two internal nodes Bolton and will not cause us to exceed the number of available pointers (2,4) Trees 31

32 Insertions and Deletions Bolton Aspen Bolton Redwood Round Hill delete <,... > In this case we are actually able to delete the root and shorten the height of the tree (reducing the block reads by one) (2,4) Trees 32

33 B+ trees Bolton Brighton Aspen Bolton Brighton Redwood Round Hill Notice in B+ trees search key values can occur more than once (in the internal nodes and in the leaf nodes) (2,4) Trees 33