Trees. Courtesy to Goodrich, Tamassia and Olga Veksler

Transcription

1 Lecture 12: BT Trees Courtesy to Goodrich, Tamassia and Olga Veksler Instructor: Yuzhen Xie

2 Outline B-tree Special case of multiway search trees used when data must be stored on the disk, i.e. too large to fit in the memory 2

3 Reasons for using B-Trees Accessing disk is MUCH slower than memory access One disk access takes around 8ms This is about the same as executing 200,000 CPU instructions It is worth executing lots of instructions to avoid a single disk access! Because accessing disk is so slow, data on a disk is stored in blocks of size B Typical block size is between 1024 bytes and 8192 bytes A whole block is read per one disk access When searching a tree, accessing each node most likely will require reading that node from the disk The larger the tree height, the more disk accesses we need Use a tree (B-tree) with high branching factor so that the height of the tree is smaller, thus requiring smaller number of disc accesses assuming a tree node fits into 1 disc block 3

4 Definition of a B-tree A B-tree of order d is a multiway search tree st: s.t.: 1. Each internal node (except the root) has between d/2 and d children (and therefore each node stores between d/2-1 to d - 1 entries). 2. All external nodes have the same depth B-tree of order 5: between 3 and 5 children B-tree is particularly suited for huge dictionaries that do not fit into main memory Height of a B-tree is ( n) log n O = O log d / 2 log d / 2 log a Here we used the property of logarithms: = logb a log b

5 Side Note on B-trees The only restriction on the root is that it has at least 2 children There is no restriction on the root to have between d/2 and d children to allow small B-trees For example, below is the only way to have a B-tree of order 5 storing 5 items, notice the root has only 2 children, whereas all other internal nodes must have between 3 and 5 children

6 Operations in B-Tree Since B-tree is a multi-way search tree, the search operation is exactly like in multi-way search trees Insert and delete operations require only minor changes from that of the (2,4)-tree Perform splits as necessary when inserting Perform transfer and fusion as necessary when deleting 6

7 Insertion Example Let B-tree be of order d = 6 Internal nodes must have between 3 and 6 children Insert new entry in the node returned by search, like in (2,4)- trees Overflow occurs when a node becomes a 7-node v insert 13 overflow! v

8 Insertion Example To handle overflow at node v, perform a split on v (d=6): Middle entry m = (d+1)/2 in v goes to parent of v, in correct place Entries 1 through (d+1)/2-1 together with children 1 though (d+1)/2 go to new node v ; v becomes child to the left of m Entries (d+1)/2 +1 through d together with children (d+1)/2 +1 through d+1 go to new node v ; v becomes child to the right of m overflow! v v v after split

9 Delete Basically identical to (2,4)-trees Ensure that entry to be deleted is at node with leaf children If not, swap the entry with its inorder successor Delete the entry at node v and the appropriate leaf child Underflow occurs if number of children left is less than d/2. Handle underflow with either transfer and fusion (transfer is preferable) Transfer, if an adjacent sibling w has at least d/2 +1 entries v gets an entry which is between v and w from its parent u, sibling w gives the entry to parent u as a replacement, this is the entry of w which is closest to the entry moved from u to v After transfer, no new underflows Fusion if both adjacent siblings have less than d/2 +1 entries merge node u with an adjacent sibling w into new entry v v gets an entry from the parent. This is the entry between the old nodes v and w After fusion, underflow at a parent node may occur.

10 Deletion Example: Degree d= w u v transfer underflow!

11 Deletion Example: Degree d= fusion underflow!

12 B-Tree Complexity Analysis for Dictionary in Main Memory Assume time spent at each node is O(d) We can implement entries at each node as an ordered dictionary using search table implementation height of B-tree with n entries is O((log n)/(log d/2 ) Thus search, insert, and delete take O((d log n)/(log d/2 ) time If the tree does fit into the memory, we are better off using a (2,4)-tree,, where search, insert, and delete have complexity O(log n) O((d log n)/(log d/2 ) = O((log n) [d /log d/2 ]) is worse than O(log n) ) 12

13 B-Tree Complexity Analysis for Dictionary Stored on a Disk If the data is stored on a disk, we have to do complexity analysis differently Let f be the time for one CPU operation, and s be the time for 1 disc access f is MUCH smaller than s, approximately s = 200,000 f When performing search, insert, and delete we spent d time at each node, and perform (log n)/(log d/2 ) disc accesses We are ignoring constants for this analysis Thus the time to perform search, insert, and delete is Time(d)= ( ) f d (log n)/(log )( g d/2 )+ s(log ( g n)/(log )( g d/2 ) fast main memory operations slow disk operations Suppose f =1, s = 200, What s the optimal value of d to minimize the Time(d) as a function of d? This is your favorite Calculus 1 problem. Taking derivative of Time(d) and setting it to 0 we get d = 4000 and setting it to 0, we get d 4000 Should make d = 4000 (if a node storing 4000 entries fits into disc block size)

14 Reasons for using B-Trees Choose d so that the d children references and the d - 1 entries stored at a node can all fit into a single disk block Since each internal node has at least d/2 children, each disk block used to support B-tree is at least half full not a lot of disk space is wasted by being empty Thus the disk block size B is O(d), andanyany search/update operation requires only O(log d/2 n)=o(log B n) time 14

15 Number of Entries in a Multiway Tree The number of entries in a multiway tree is the number of external nodes 1 Proof: Put one stone on each leaf and pass the stones from the leaves up the tree. Each internal node keeps 1 stone per entry, and passes the rest to its parent. Since #entries = #children 1, each internal node will pass only 1 stone to its parent. This process stops at the root, and the root will pass 1 stone outside the tree. At the end, each entry has 1 stone, and 1 stone is outside the tree

16 Number of Entries in a Multiway Tree

17 Number of Entries in a Multiway Tree

18 Reasons for using B-Trees For example, if we use a B-tree of order 200, this size is usually small enough so that we can transfer each node in one disc read operation A B-tree of order 200 and height 3 can hold entries (approximately 8 million) and any item can be accessed with 2 disc reads Assuming we hold the root in memory, which makes sense since root is node which is always gets accessed for any operation Level 0: =1 internal nodes Level 1: internal nodes Level 2: internal nodes Level 3: external nodes

19 Comparing Trees (Finally Done with Search Trees) Binary Trees Binary search tree Not necessarily balanced if keys are inserted/deleted randomly, performance can be close to optimal, O(log n). However in the worst case, performance is O(n) AVL-tree Guaranteed to be balanced with O(log n) performance, but more complicated to maintain i than BST Multi-way trees (2,4) tree is balanced. Guaranteed O(log n) time performance, but is complicated to implement. B-Trees is balanced, useful for dictionary located in external (disk) memory. 19