18.3 Deleting a key from a B-tree

Transcription

1 18.3 Deleting a key from a B-tree B-TREE-DELETE deletes the key from the subtree rooted at We design it to guarantee that whenever it calls itself recursively on a node, the number of keys in is at least the minimum degree This condition requires one more key than the minimum required by usual B-tree conditions Sometimes a key may have to be moved into a child node before recursion descends to that child MAT AA+DS, Fall Nov The strengthened condition allows us to delete a key in one downward pass without having to back up (with one exception) Interpret the following speci cation for deletion from a B-tree with the understanding that if the root node ever becomes an internal node having no keys (this situation can occur in cases 2c and 3b), then we delete, and s only child becomes the new root of the tree, decreasing the height of the tree by one and preserving the property that the root of the tree contains at least one key (unless it is empty) MAT AA+DS, Fall Nov

2 MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

3 MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

4 MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

5 Let us sketch how deletion works 1. If the key is a leaf node, delete from 2. If is in an internal node, do the following: a) If the child that precedes in node has at least keys, then nd the predecessor of in the subtree rooted at. Recursively delete, and replace by in. (We can nd and delete it in a single downward pass.) b) If has fewer than keys, then, symmetrically, examine the child that follows in node. If has at least keys, then nd the successor of in the subtree rooted at. Recursively delete, and replace by in. MAT AA+DS, Fall Nov c) Otherwise, if both and have only 1keys, merge and all of into, so that loses both and the pointer to, and now contains 1keys. Then free and recursively delete from. 3. If the key is not present in internal node, determine the root of the appropriate subtree that must contain, if is in the tree at all. If has only 1keys, execute step 3a or 3b as necessary to guarantee that we descend to a node containing at least keys. Then nish by recursing on the appropriate child of. MAT AA+DS, Fall Nov

6 a) If has only 1keys but has an immediate sibling with at least keys, give an extra key by moving a key from down into, moving a key from s immediate left or right sibling up into, and moving the appropriate child pointer from the sibling into. b) If and both of s immediate siblings have 1keys, merge with one sibling, which involves moving a key from down into the new merged node to become the median key for that node. MAT AA+DS, Fall Nov Most of the keys in a B-tree are in the leaves and we may expect that in practice deletions are most often used to delete keys from leaves B-TREE-DELETE then acts in one downward pass through the tree, without having to back up When deleting a key in an internal node, the procedure may have to return to replace the key with its predecessor or successor (2a and 2b) This involves only ) disk operations for a B- tree of height, since only (1) calls to DISK- READ and DISK-WRITE are made between recursive invocations of the procedure The CPU time required is = ( log ) MAT AA+DS, Fall Nov

7 19 Fibonacci Heaps 1. The Fibonacci heap data structure supports a set of operations that constitutes what is known as a mergeable heap 2. Several Fibonacci-heap operations run in constant amortized time, which makes this data structure well suited for applications that invoke these operations frequently MAT AA+DS, Fall Nov Mergeable heaps Support the following operations, each element has a key: MAKE-HEAP() creates and returns a new empty heap INSERT inserts element, whose key has already been lled in, into heap MINIMUM ) returns a pointer to the element in heap whose key is minimum EXTRACT-MIN ) deletes the element from heap whose key is minimum, returning a pointer to the element MAT AA+DS, Fall Nov

8 UNION creates and returns a new heap that contains all the elements of heaps and. Heaps and are destroyed by this operation Fibonacci heaps also support the following two operations: DECREASE-KEY ) assigns to element within heap the new key value, which we assume to be no greater than its current key value DELETE ) deletes element from heap MAT AA+DS, Fall Nov Procedure Binary Heap (worst-case) Fibonacci Heap (amortized) MAKE-HEAP (1) (1) INSERT (lg ) (1) MINIMUM (1) (1) EXTRACT-MIN (lg ) (lg ) UNION ) (1) DECREASE-KEY (lg ) (1) DELETE (lg ) (lg ) MAT AA+DS, Fall Nov

9 Fibonacci heaps in theory and practice Fibonacci heaps are especially desirable when the number of EXTRACT-MIN and DELETE operations is small relative to the number of other operations performed E.g., some algorithms for graph problems may call DECREASE-KEY once per edge For dense graphs, with many edges, the (1) amortized time of each call of DECREASE-KEY is a big improvement over the (lg ) worst-case time of binary heaps Fast algorithms for problems such as computing minimum spanning trees and nding single-source shortest paths make essential use of Fibonacci heaps MAT AA+DS, Fall Nov The constant factors and programming complexity of Fibonacci heaps make them less desirable than ordinary binary (or -ary) heaps for most applications, except for certain applications that manage large amounts of data Thus, Fibonacci heaps are predominantly of theoretical interest If a much simpler data structure with the same amortized time bounds as Fibonacci heaps were developed, it would be of practical use as well MAT AA+DS, Fall Nov

10 Fibonacci heaps are based on rooted trees We represent each element by a node within a tree, and each node has a key attribute We use the term node instead of element We also ignore issues of allocating nodes prior to insertion and freeing nodes following deletion A Fibonacci heap is a collection of rooted trees that are min-heap ordered I.e., each tree obeys the min-heap property: the key of a node is greater than or equal to the key of its parent MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

11 Each node contains a pointer to its parent and a pointer to any one of its children The children of are linked together in a circular, doubly linked list the child list of Each child in a child list has pointers and that point to s left and right siblings, respectively If is an only child, then Siblings may appear in a child list in any order MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

12 We store the number of children in the child list of node in The Boolean attribute indicates whether node has lost a child since the last time was made the child of another node Newly created nodes are unmarked, and a node becomes unmarked whenever it is made the child of another node Until we look at the DECREASE-KEY operation we will just set all mark attributes to FALSE We access a given Fibonacci heap by a pointer. min to the root of a tree containing the minimum key MAT AA+DS, Fall Nov When a Fibonacci heap is empty,. min is NIL The roots of all the trees in a heap are linked together using their left and right pointers into a circular, doubly linked list called the root list The pointer. min thus points to the node in the root list whose key is minimum Trees may appear in any order within a root list We rely on one other attribute for a Fibonacci heap :, the number of nodes currently in MAT AA+DS, Fall Nov

13 Potential function We use the potential method to analyze the performance of Fibonacci heap operations Let ) be the number of trees in the root list of Fibonacci heap and ) the number of marked nodes in We de ne the potential ) of heap by + 2 ) For example, the potential of the Fibonacci heap shown above is 5+2 3=11 MAT AA+DS, Fall Nov The potential of a set of Fibonacci heaps is the sum of the potentials of its constituent heaps We assume that a unit of potential can cover the cost of any of the speci c constant-time pieces of work that we might encounter Fibonacci heap application begins with no heaps The initial potential, therefore, is 0, and the potential is nonnegative at all subsequent times An upper bound on the total amortized cost thus provides an upper bound on the total actual cost for the sequence of operations MAT AA+DS, Fall Nov

14 Maximum degree Amortized analyses we perform assume that we know an upper bound ) on the maximum degree of any node in an -node Fibonacci heap When only the mergeable-heap operations are supported lg We shall show that when we support DECREASE- KEY and DELETE as well, (lg ) MAT AA+DS, Fall Nov Mergeable-heap operations The operations delay work as long as possible; various operations have performance trade-offs E.g., we insert a node by adding it to the root list, which takes just constant time If we insert nodes to an empty Fibonacci heap, the heap consist of just a root list of nodes Trade-off: if we then perform EXTRACT-MIN on, after removing the node that. min points to, we have to look through each of the remaining 1 nodes to nd the new minimum node MAT AA+DS, Fall Nov

15 As long as we have to go through the entire root list during the EXTRACT-MIN operation, we also consolidate nodes into min-heapordered trees to reduce the size of the root list We shall see that, no matter what the root list looks like before a EXTRACT-MIN operation, afterward each node in the root list has a degree that is unique within the root list, which leads to a root list of size at most +1 MAT AA+DS, Fall Nov Creating a new Fibonacci heap To make an empty Fibonacci heap, the MAKE- FIB-HEAP procedure allocates and returns the Fibonacci heap object, where =0and =NIL; there are no trees in Because =0and =0, the potential of the empty Fibonacci heap is =0 The amortized cost of MAKE-FIB-HEAP is thus equal to its (1) actual cost MAT AA+DS, Fall Nov

16 FIB-HEAP-INSERT(, ) 1. =0 2. =NIL 3. =NIL 4. =FALSE 5. if == NIL 6. create a root list for containing just 7..min= 8. else insert into s root list 9. if. min. 10..min= 11.. =. +1 MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

17 To determine the amortized cost of FIB-HEAP- INSERT, let be the input Fibonacci heap and be the resulting Fibonacci heap Then, +1and ), and the increase in potential is =1 Since the actual cost is (1), the amortized cost is = (1) MAT AA+DS, Fall Nov FIB-HEAP-UNION 1. =MAKE-FIB-HEAP() 2..min=. min 3. concatenate the root list of with the root list of 4. if. min == NIL) or.min NIL and.min.. min. ) 5..min=. min return MAT AA+DS, Fall Nov

18 The change in potential is ) = ( + 2 ( =0 because and = The amortized cost of FIB-HEAP-UNION is therefore equal to its (1) actual cost MAT AA+DS, Fall Nov Extracting the minimum node The process of extracting the minimum node is the most complicated of the operations so far It is also where the delayed work of consolidating trees in the root list nally occurs The following code assumes that when a node is removed, pointers remaining in the linked list are updated, but pointers in the extracted node are left unchanged It also calls the auxiliary procedure CONSOLIDATE MAT AA+DS, Fall Nov

19 FIB-HEAP-EXTRACT-MIN( ) 1.. min 2. if NIL 3. for each child of 4. add to the root list of 5. =NIL 6. remove from the root list of 7. if == 8..min=NIL 9. else. min = 10. CONSOLIDATE ) return MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

20 The next step reduces the number of trees in the Fibonacci heap, CONSOLIDATE accomplishes this Consolidating the root list consists of repeatedly executing the following steps until every root in the root list has a distinct degree value: 1. Find two roots and in the root list with the same degree. Without loss of generality, let 2. Link to : remove from the root list, and make a child of by calling the FIB-HEAP-LINK procedure. This procedure increments the attribute. and clears the mark on MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

21 MAT AA+DS, Fall Nov Decreasing a key FIB-HEAP-DECREASE-KEY ) 1. if 2. error new key is greater than current key if NIL and 6. CUT ) 7. CASCADING-CUT ) 8. if. min. 9.. min = MAT AA+DS, Fall Nov

22 CUT(,, ) 1. remove from the child list of, decrementing 2. add to the root list of 3. =NIL 4. =FALSE CASCADING-CUT ) if NIL 3. if == FALSE 4. =TRUE 5. else CUT 6. CASCADING-CUT(, ) MAT AA+DS, Fall Nov MAT AA+DS, Fall Nov

23 FIB-HEAP-DECREASE-KEY creates a new tree rooted at node and clears s mark bit Each of the calls of CASCADING-CUT, except the last one, cuts a marked node and clears the mark bit Afterward, the heap contains trees the original trees, 1trees produced by cascading cuts, and the tree rooted at and at most +2marked nodes 1were unmarked by cascading cuts and the last call of CASCADING-CUT may have marked a node MAT AA+DS, Fall Nov The change in potential is therefore at most =4 Thus, the amortized cost of FIB-HEAP-DECREASE- KEY is at most + 4 (1), since we can scale up the units of potential to dominate the constant hidden in When a marked node is cut by a cascading cut, its mark bit is cleared, which reduces the potential by 2 One unit of potential pays for the cut and the clearing of the mark bit, and the other unit compensates for the unit increase in potential due to node becoming a root MAT AA+DS, Fall Nov

24 Deleting a node We assume that there is no key value of currently in the Fibonacci heap FIB-HEAP-DELETE ) 1. FIB-HEAP-DECREASE-KEY ) 2. FIB-HEAP-EXTRACT-MIN ) The amortized time of FIB-HEAP-DELETE is the sum of the (1) amortized time of FIB-HEAP- DECREASE-KEY and the )amortized time of FIB-HEAP-EXTRACT-MIN MAT AA+DS, Fall Nov