Data Structures. Binomial Heaps Fibonacci Heaps. Haim Kaplan & Uri Zwick December 2013

Transcription

1 Data Structures Binomial Heaps Fibonacci Heaps Haim Kaplan & Uri Zwick December 13 1

2 Heaps / Priority queues Binary Heaps Binomial Heaps Lazy Binomial Heaps Fibonacci Heaps Insert Find-min Delete-min Decrease-key Meld Worst case Amortized Delete can be implemented using Decrease-key + Delete-min Decrease-key in time important for Dijkstra and Prim

3 Binomial Heaps [Vuillemin (1978)] 3

4 Binomial Trees B 0 B 1 B 2 B 3 B 4 4

5 Binomial Trees B 0 B 1 B 2 B 3 B 4 5

6 Binomial Trees B 0 B 1 B 2 B 3 B k B k B k 1 B k 1 B k 1 B k 2 6

7 Binomial Trees B 0 B k B k B k 1 B k 1 B k 1 B k 2 7

8 Min-heap Ordered Binomial Trees key of child key of parent 8

9 Tournaments Binomial Trees D D D F F A C A D F G G E B A B C D E F G H H The children of x are the items that lost matches with x, in the order in which the matches took place. 9

10 Binomial Heap A list of binomial trees, at most one of each rank Pointer to root with minimal key Each number n can be written in a unique way as a sum of powers of 2 11 = (1011) 2 = At most log 2 (n+1) trees

11 Ordered forest Binary tree x 23 info key child next pointers per node child leftmost child next next sibling 11

12 Forest Binary tree Heap order half ordered

13 Q Binomial heap representation n first min 2 pointers per node No explicit rank information How do we determine ranks? x info key child next Structure V [Brown (1978)]

14 Q Alternative representation n first min Reverse sibling pointers Make lists circular Avoids reversals during meld info key child next Structure R [Brown (1978)]

15 Linking binomial trees y b a b x a B k B k 1 B k 1 time 15

16 Linking binomial trees Linking in first representation Linking in second representation 16

17 Melding binomial heaps Link trees of same degree Q 1 : Q 2 :

18 Melding binomial heaps Link trees of same degree B 1 B 2 B 3 Q 1 : B 0 B 1 B 3 Q 2 : B 0 B 2 B 3 B 3 B 4 Like adding binary numbers Maintain a pointer to the minimum time 18

19 Insert New item is a one tree binomial heap Meld it to the original heap time 19

20 Delete-min When we delete the minimum, we get a binomial heap

21 Delete-min When we delete the minimum, we get a binomial heap Meld it to the original heap time (Need to reverse list of roots in first representation) 21

22 Decrease-key using sift-up I Decrease-key(Q,I,7) 22

23 Decrease-key using sift-up I Need parent pointers (not needed before) 23

24 Decrease-key using sift-up I Need to update the node pointed by I 24

25 Decrease-key using sift-up I Need to update the node pointed by I 25

26 Decrease-key using sift-up I How can we do it?

27 Q n first min Adding parent pointers

28 Q n first min Adding a level of indirection Endogenous vs. exogenous I 23 x info key node item child next parent Nodes and items are distinct entities 28

29 Heaps / Priority queues Binary Heaps Binomial Heaps Lazy Binomial Heaps Fibonacci Heaps Insert Find-min Delete-min Decrease-key Meld Worst case Amortized

30 Lazy Binomial Heaps 30

31 Binomial Heaps A list of binomial trees, at most one of each rank, sorted by rank (at most trees) Pointer to root with minimal key Lazy Binomial Heaps An arbitrary list of binomial trees (possibly n trees of size 1) Pointer to root with minimal key

32 Lazy Binomial Heaps An arbitrary list of binomial trees Pointer to root with minimal key

33 Lazy Meld Concatenate the two lists of trees Update the pointer to root with minimal key worst case time Lazy Insert Add the new item to the list of roots Update the pointer to root with minimal key worst case time 33

34 Lazy Delete-min? Remove the minimum root and meld? May need (n) time to find the new minimum

35 Consolidating / Successive Linking

36 Consolidating / Successive Linking

37 Consolidating / Successive Linking

38 Consolidating / Successive Linking

39 Consolidating / Successive Linking

40 Consolidating / Successive Linking

41 Consolidating / Successive Linking

42 Consolidating / Successive Linking

43 Consolidating / Successive Linking

44 Consolidating / Successive Linking At the end of the process, we obtain a non-lazy binomial heap containing at most log (n+1) trees, at most one of each rank

45 Consolidating / Successive Linking At the end of the process, we obtain a non-lazy binomial heap containing at most log n trees, at most one of each degree Worst case cost O(n) Amortized cost Potential = Number of Trees

46 Cost of Consolidating T 0 Number of trees before T 1 Number of trees after L Number of links T 1 = T 0 L (Each link reduces the number of tree by 1) Total number of trees processed T 0 +L (Each link creates a new tree) Putting trees into buckets or finding trees to link with Linking Handling the buckets Total cost = O( (T 0 +L) + L + log 2 n ) = O( T 0 + log 2 n ) As L T 0

47 Amortized Cost of Consolidating (Scaled) actual cost = T 0 + log 2 n Change in potential = = T 1 T 0 Amortized cost = (T 0 + log 2 n ) + (T 1 T 0 ) = T 1 + log 2 n 2 log 2 n As T 1 log 2 n Another view: A link decreases the potential by 1. This can pay for handling all the trees involved in the link. The only unaccounted trees are those that were not the input nor the output of a link operation.

48 Lazy Binomial Heaps Actual cost Change in potential Amortized cost Insert 1 Find-min 0 Delete-min O(k+T 0 +log n) k 1+T 1 T 0 Decrease-key 0 Meld 0 Rank of deleted root

49 Heaps / Priority queues Binary Heaps Binomial Heaps Lazy Binomial Heaps Fibonacci Heaps Insert Find-min Delete-min Decrease-key Meld Worst case Amortized

50 One-pass successive linking A tree produced by a link is immediately put in the output list and not linked again Worst case cost O(n) Amortized cost Potential = Number of Trees Exercise: Prove it!

51 One-pass successive Linking

52 One-pass successive Linking

53 One-pass successive Linking Output list: 10 29

54 Fibonacci Heaps [Fredman-Tarjan (1987)] 54

55 Decrease-key in time? 2 x Decrease-key(Q,x,30) 55

56 Decrease-key in time? 2 x Decrease-key(Q,x,10) 56

57 Decrease-key in time? 2 x Heap order violation 57

58 Decrease-key in time? 2 x Cut the edge 58

59 Decrease-key in time? 2 x Tree no longer binomial 59

60 Fibonacci Heaps A list of heap-ordered trees Pointer to root with minimal key Not all trees may appear in Fibonacci heaps 60

61 Q Fibonacci heap representation min 23 Explicit ranks = degrees Doubly linked lists of children Arbitrary order of children child points to an arbitrary child pointers + rank + mark bit per node 61

62 Q Fibonacci heap representation x min info key rank mark child next prev parent pointers + rank + mark bit per node

63 Are simple cuts enough? A binomial tree of rank k contains at least 2 k We may get trees of rank k containing only k+1 nodes Ranks not necessarily Analysis breaks down 63

64 Cascading cuts Invariant: Each node looses at most one child after becoming a child itself To maintain the invariant, use a mark bit Each node is initially unmarked. When a non-root node looses its first child, it becomes marked When a marked node looses a second child, it is cut from its parent 64

65 Cascading cuts Invariant: Each node looses at most one child after becoming a child itself When x y is cut: x becomes unmarked If y is unmarked, it becomes marked If y is marked, it is cut from its parent Our convention: Roots are unmarked 65

66 Cascading cuts Cut x from its parent y Perform a cascading-cut process starting at x 66

67 Cascading cuts 67

68 Cascading cuts 68

69 Cascading cuts 69

70 Cascading cuts 70

71 Cascading cuts 71

72 Cascading cuts 72

73 Cascading cuts 73

74 Cascading cuts 74

75 Cascading cuts 75

76 Number of cuts A decrease-key operation may trigger many cuts Lemma 1: The first d decrease-key operations trigger at most 2d cuts Proof in a nutshell: Number of times a second child is lost is at most the number of times a first child is lost Potential = Number of marked nodes 76

77 Number of cuts Potential = Number of marked nodes Amortized number of cuts c + (1 (c 1)) = 2

78 Trees formed by cascading cuts Lemma 2: Let x be a node of rank k and let y 1,y 2,,y k be the current children of x, in the order in which they were linked to x. Then, the rank of y i is at least i 2. Proof: When y i was linked to x, y 1, y i 1 were already children of x. At that time, the rank of x and y i was at least i 1. As y i is still a child of x, it lost at most one child. 78

79 Trees formed by cascading cuts Lemma 3: A node of rank k in a Fibonacci Heap has at least F k+2 k descendants, including itself. n F n

80 Trees formed by cascading cuts Lemma 3: A node of rank k in a Fibonacci Heap has at least F k+2 k descendants, including itself. k 2 k 3 k Let S k be the minimum number of descendants of a node of rank at least k 80

81 Trees formed by cascading cuts Lemma 3: A node of rank k in a Fibonacci Heap has at least F k+2 k descendants, including itself. Corollary: In a Fibonacci heap containing n items, all ranks are at most log n log 2 n Ranks are again Are we done? 81

82 Putting it all together Are we done? A cut increases the number of trees We need a potential function that gives good amortized bounds on both successive linking and cascading cuts Potential = #trees + 2 #marked 82

83 Cost of Consolidating T 0 Number of trees before T 1 Number of trees after L Number of links T 1 = T 0 L (Each link reduces the number of tree by 1) Total number of trees processed T 0 +L (Each link creates a new tree) Putting trees into buckets or finding trees to link with Linking Handling the buckets Total cost = O( (T 0 +L) + L + log n ) = O( T 0 + log n ) As L T 0

84 Cost of Consolidating T 0 Number of trees before T 1 Number of trees after L Number of links T 1 = T 0 L (Each link reduces the number of tree by 1) Total number of trees processed T 0 +L (Each link creates a new tree) Only change: log n instead of log 2 n Total cost = O( (T 0 +L) + L + log n ) = O( T 0 + log n ) As L T 0

85 Fibonacci heaps Actual cost Trees Marks Amortized cost Insert 1 0 Find-min 0 0 Delete-min Decreasekey Meld O(k+T 0 +log n) O(c) k 1+T 1 T 0 c 0 Rank of deleted root 0 2 c 0 Number of cuts performed

86 Heaps / Priority queues Binary Heaps Binomial Heaps Lazy Binomial Heaps Fibonacci Heaps Insert Find-min Delete-min Decrease-key Meld Worst case Amortized

87 Consolidating / Successive linking