1. Fibonacci Heap

2. p2. Procedure Binary heap (worst-case) Fibonacci heap (amortized) MAKE-HEAP  (1) INSERT  (lg n)  (1) MINIMUM  (1) EXTRACT-MIN  (lg n) O(lg n) UNION  (n)  (1) DECREASE-KEY  (lg n)  (1) DELETE  (lg n) O(lg n)

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

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

5. p5. Fibonacci Heaps: a collection of min-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

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)

7. p7. Mergeable-heap operations: Create a new Fibonacci 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.

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 H’s 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

9. p9. Finding the minimum node: H.min  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<H 1.min.key) 5. H.min = H 2.min 6. H.n = H 1.n + H 2.n 7. return H

10. p10.  (H) - (  (H 1 )+  (H 2 )) = (t(H)+2m(H)) – ((t(H 1 )+2m(H 1 )) + (t(H 2 )+2m(H 2 ))) = 0 t(H) = t(H 1 ) + t(H 2 ), m(H) = m(H 1 ) + m(H 2 ) Thus the amortized cost of Fib-Heap-Union is therefore O(1)  actual cost

11. p11. Extracting the minimum node: Fib-Heap-Extract-Min(H) 1. z = H.min 2. if z  NIL 3. for each child x of z 4. do { add x to the root list of H 5. x.p = NIL } 6. remove z from the root list of H 7. if z == z.right 8. H. min = NIL 9. else H.min = z.right 10. Consolidate(H) 11. H.n = H.n – 1 12. return z

12. 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 H’s root list 17. if A[i].key < H.min.key H.min = A[i]

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

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

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

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

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

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

19. p19. 35 (m) 23 7 39 18 41 38 30 17 24 26 46 21 52 H.min

20. p20. 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))

21. p21. Decreasing a key and deleting a node: Decrease a key in O(1) amortized time and delete a node in O(D(n)) amortized time. 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

22. p22. 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) }

23. p23. 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

24. p24. (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

25. p25. (e) 15 41 38 39 18 21 52 23 7 30 17 5 26 H.min 24

26. p26. 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)

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

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

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:

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

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)