# Fibonacci Heap. p2. Procedure Binary heap (worst-case) Binomial heap (worst-case) Fibonacci heap (amortized) MAKE-HEAP  (1) INSERT  (lg n) O(lg n) 

Dec 21, 2015

## Documents

• Slide 1
• Fibonacci Heap
• Slide 2
• p2. Procedure Binary heap (worst-case) Binomial heap (worst-case) Fibonacci heap (amortized) MAKE-HEAP (1) INSERT (lg n) O(lg n) (1) MINIMUM (1) O(lg n) (1) EXTRACT-MIN (lg n) O(lg n) UNION (n) O(lg n) (1) DECREASE-KEY (lg n) (1) DELETE (lg n) O(lg n)
• Slide 3
• p3. (a) 237 41 39 24 30 17 3818 52 26 3 46 35 H.min (b) 237 41 39 24 30 17 3818 52 26 3 46 35 H.min
• Slide 4
• p4. (a) 237 41 39 24 30 17 3818 52 26 3 46 35 H.min (b) 237 41 39 24 30 17 3818 52 26 3 46 35 21 Insert key 21
• Slide 5
• p5. Fibonacci Heaps: A collection of heap-ordered trees. trees: rooted but unordered Each node x: x.p points to its parent x.child points to any one of its children children of x are linked together in a circular doubly linked list x.Left, x.right: points to its left and right siblings. x.degree: number of children in the child list of x x.mark: indicate whether node x has lost a child since the last time x was mode the child of another node H.min: points to the root of the tree containing a minimum key H.n: number of nodes in H
• Slide 6
• p6. Potential function: D(n): upper bound on the max degree of any node in an n-node Fibonacci heap Fibonacci heap # of trees in the rooted list of H # of marked nodes in H (H) = t(H) + 2m(H)
• Slide 7
• p7. Unordered binomial tree: U 0 : a single node U k : consists of 2 unordered binomial trees U k-1 for which the root of one is made into any child of the root of the other Make-Heap, Insert, Minimum, Extract-Min & Union. Fibonacci heap unordered binomial trees. Make-Heap, Make-Fib-Heap(H): Allocate and return the Fibonacci heap object H with H.n=0 and H.min=nil t(H)=0, m(H)=0 so (H)=0 The amortized cost of Make-Fib-Heap is equal to its O(1) actual cost.
• Slide 8
• p8. Fib-Heap-Insert(H, x) 1. x.degree = 0 2. x.p = NIL 3. x.child = NIL 4. x.mark = FALSE 5. if H.min == NIL 6. create a root list for H containing just x 7. H.min = x 8. else insert x into Hs root list 9. if x.key < H.min.key 10. H.min = x 11. H.n = H.n +1 Actual cost: O(1); Amortized cost: O(1) + 1
• Slide 9
• p9. Finding the minimum node: min[H] O(1) Amortized cost O(1) is not changed Uniting 2 Fibonacci heaps: Fib-Heap-Union(H 1, H 2 ) 1. H = Make-Fib-Heap( ) 2. H.min = H 1.min 3. concatenate the root list of H 2 with the root list of H 4. if (H 1.min == NIL) or (H 2.min NIL and H 2.min.key
• p12. Fib-Heap-Link(H, y, x) {1. remove y from the root list of H; 2. make y a child of x; x.degree =x.degree+1; 3. y.mark = FALSE; } Consolidate(H) 1. let A[0..D(H.n)] be a new array 2. for i = 0 to D(n[H]) do A[i]=NIL 3. for each node w in the root list of H 4. do { x = w ; d = x.degree; 5. while A[d] NIL 6. do { y = A[d] 7. if x.key > y.key exchange x y 8. Fib-Heap-Link(H, y, x) 9. A[d] = NIL ; d = d+1; } 10. A[d] = x; } 11. H.min = NIL 12. for i = 0 to D(H.n) do 13. if A[i] NIL 14. if H.min==NIL 15. create a root list for H containing just A[i]; H.min =A[i]; 16. else insert A[i] into Hs root list 17. if A[i].key < H.min.key H.min = A[i]
• Slide 13
• p13. (a) 237 41 39 24 30 17 3818 52 26 3 46 35 21 (b) 23724 26 46 35 39 18 41 38 30 1721 52 H.min
• Slide 14
• p14. (c) 23724 26 46 35 39 18 41 38 30 1721 52 0 1 2 3 4 A w,x 0 1 2 3 4 A (d) 23724 26 46 35 39 18 41 38 30 1721 52 w,x
• Slide 15
• p15. 0 1 2 3 4 A (e) 23724 26 46 35 39 18 41 38 30 1721 52 w,x (f) 23 7 0 1 2 3 4 A 24 26 46 35 39 18 41 38 30 17 21 52 x w
• Slide 16
• p16. 0 1 2 3 4 A (g) 23 7 24 26 46 35 39 18 41 38 30 17 21 52 x w 35 (h) 0 1 2 3 4 A 23 7 39 18 41 38 30 17 24 26 46 21 52 x w
• Slide 17
• p17. 0 1 2 3 4 35 (i) A 23 7 39 18 41 38 30 17 24 26 46 21 52 w, x 0 1 2 3 4 35 (j) A 23 7 39 18 41 38 30 17 24 26 46 21 52 w, x
• Slide 18
• p18. 0 1 2 3 4 35 (k) A 23 7 39 18 41 38 30 17 24 26 46 21 52 w, x 0 1 2 3 4 35 (l) A 23 7 39 18 41 38 30 17 24 26 46 21 52 w, x
• Slide 19
• p19. 35 (m) 23 7 39 18 41 38 30 17 24 26 46 21 52 H.min
• Slide 20
• p20. Decreasing a key and deleting a node: do not preserve the property that all trees in the Fibonacci heap are unordered binomial trees. Fib-Heap-Decrease-key(H, x, k) 1. if k>x.key 2. error new key is greater than current key 3. x.key = k 4. y x.p 5. if y NIL and x.key< y.key 6. { CUT(H, x, y) 7. CASCADING-CUT(H, y) } 8. if x.key< H.min.key 9. H.min = x
• Slide 21
• p21. CUT(H, x, y) 1. remove x from the child list of y, decrease y.degree 2. add x to the root list of H 3. x.p = NIL 4. x.mark = FALSE CASCADING-CUT(H, y) 1. z y.p 2. if z NIL 3. if y.mark == FALSE 4. y.mark= TRUE 5. else CUT(H, y, z) 6. CASCADING-CUT(H, z) Fib-Heap-Delete(H, x) { Fib-Heap-Decrease-key(H, x, - ) Fib-Heap-Extract-Min(H) }
• Slide 22
• p22. 35 (a) 23 7 39 18 41 38 30 17 24 26 46 21 52 H.min (b) 15 35 26 23 7 41 38 30 17 24 39 18 21 52 H.min
• Slide 23
• p23. (c) 15 26 23 7 41 38 30 17 24 39 18 21 52 H.min 5 (d) 15 41 38 39 18 21 52 23 7 30 17 24 H.min 5 26
• Slide 24
• p24. (e) 15 41 38 39 18 21 52 23 7 30 17 5 26 H.min 24
• Slide 25
• p25. Analysis of Decrease-key: Actual cost : O(c) suppose CASCADING-CUT is called c times Each recursive call of CASCADING-CUT except for the last one, cuts a marked node and clears the mark bit. After Decrease-key, there are at most t(H)+c trees, and at most m(H)-c+2 marked nodes. Last call of CASCADING-CUT may have marked a node Thus; the potential change is : [t(H)+c+2(m(H)-c+2)] - [t(H)+2m(H)] = 4-c Amortized cost: O(c)+4-c = O(1) By scaling up the units of potential to dominate the constant hidden in O(c)
• Slide 26
• p26. Analysis of Fib-Heap-Extract-Min: H : n-node Fib-Heap Actual cost : O(D(n)) : for-loop in Fib-Heap-Extract-Min D(n)+t(H)-1 : size of the root list Total actual cost: O(D(n))+t(H) Potential before extracting : t(H)+2m(H) Potential after extracting : D(n)+1+2m(H) At most D(n)+1 nodes remain on the list and no nodes become marked Thus the amortized cost is at most: O(D(n))+t(H)+[(D(n)+1+2m(H)) (t(H)+2m(H))] = O(D(n)+t(H)-t(H)) = O(D(n))
• Slide 27
• p27. Bounding the maximum degree: Goal : D(n) log n , = Let size(x) be the number of nodes, including x itself, in the subtree rooted at x
• Slide 28
• p28. Lemma 1 x : any node in a Fibonacci heap and x.degree=k y 1, , y k : children of x in the order in which they were linked to x. (from the earliest to the latest) Then, y 1.degree 0 and y i.degree i-2 for i=2,3,,k Pf: Clearly, y 1.degree 0 For i 2, note that when y i was linked to x, all of y 1, , y i-1 were children of x, so we MUST have had x.degree i-1. Node y i is linked to x only if x.degree = y i.degree, thus y i.degree i-1 at that time. Since then, node y i has lost at most ONE child, since it would have been cut from x if it had lost two children. We conclude that y i.degree i-2 x y1y1 y2y2 ykyk
• Slide 29
• p29. Lemma 2: For all integer k 0, pf: By induction on k k=0, F 2 =F 1 +F 0 =1 = 1+F 0 Suppose Fibonacci number:
• Slide 30
• p30. Lemma 3: x: any node in a Fibonacci heap, and let k=x.degree Then, size(x) F k+2 k pf: S k : denote the min possible value of size(z) over all nodes z such that z.degree=k. Trivially, S 0 =1, S 1 =2, and S 2 =3 S k size(x), size(y 1 ) 1 size(x) S k 2+ i=2,,k S i-2 By induction on k that S k F k+2 Clearly for k=0 and 1 Assume that k 2 and that S i F i+2 for i=0,,k-1 We have S k 2+ i=2,,k S i-2 2+ i=2,,k F i = 1+ i=0,,k F i = F k+2 Thus, size(x) S k F k+2 k x y1y1 y2y2 ykyk S 0 S k-2
• Slide 31
• p31. Corollary 4: The max degree D(n) of any node in an n-node Fibonacci heap is O(lg n) pf: x: any node in an n-node Fibonacci heap k=degree[x] n size(x) k log n k Thus the max degree D(n) of any node is O(lg n)
Welcome message from author