Data Structures Binomial Heaps Fibonacci Heaps Haim Kaplan & Uri Zwick

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

Heaps / Priority queues
Fibonacci Heaps Lazy Binomial Heaps Binomial Heaps Binary Heaps O(1) O(log n) Insert Find-min Delete-min Decrease-key – Meld Worst case Amortized Delete can be implemented using Decrease-key + Delete-min Decrease-key in O(1) time important for Dijkstra and Prim

Binomial Heaps [Vuillemin (1978)]

Binomial Trees B0 B1 B2 B3 B4

Binomial Trees B0 B1 B2 B3 Bk−1 Bk−2 … Bk Bk Bk−1

Binomial Trees Bk−1 Bk−2 … Bk Bk Bk−1 B0

Min-heap Ordered Binomial Trees
2 15 5 17 25 40 20 35 18 11 38 45 58 31 45 67 key of child  key of parent

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

Binomial Heap A list of binomial trees, at most one of each rank
Pointer to root with minimal key 23 9 33 45 67 40 58 20 31 15 35 Each number n can be written in a unique way as a sum of powers of 2 At most log2 (n+1) trees 11 = (1011)2 = 8+2+1

Ordered forest  Binary tree
23 9 15 x 33 40 20 35 info key child next 45 58 31 67 child – leftmost child 2 pointers per node next – next “sibling”

Heap order  “half ordered”
Forest  Binary tree 40 45 20 67 58 31 35 9 15 33 23 23 9 33 45 67 40 58 20 31 15 35 Heap order  “half ordered”

Binomial heap representation
Q 2 pointers per node n first No explicit rank information min How do we determine ranks? x 23 9 15 33 40 20 35 info key child next 45 58 31 “Structure V” [Brown (1978)] 67

Alternative representation
Q Reverse sibling pointers n first Make lists circular min Avoids reversals during meld 23 9 15 33 40 20 35 info key child next 45 58 31 “Structure R” [Brown (1978)] 67

Linking binomial trees
a ≤ b x Bk a Bk−1 y b Bk−1 O(1) time

Linking binomial trees
Linking in first representation Linking in second representation

Melding binomial heaps
Link trees of same degree Q1: Q2:

Melding binomial heaps
Link trees of same degree B1 B2 B3 Q1: B0 B1  B3 Q2: B0  B2 B3    B3 B4 Like adding binary numbers Maintain a pointer to the minimum O(log n) time

Insert O(log n) time New item is a one tree binomial heap
11 23 15 33 9 40 20 35 45 58 31 67 New item is a one tree binomial heap Meld it to the original heap O(log n) time

When we delete the minimum, we get a binomial heap
Delete-min 23 15 33 9 40 20 35 When we delete the minimum, we get a binomial heap 45 58 31 67

Delete-min O(log n) time
23 15 33 40 20 35 When we delete the minimum, we get a binomial heap 45 58 31 67 Meld it to the original heap (Need to reverse list of roots in first representation) O(log n) time

Decrease-key using “sift-up”
2 I 15 5 17 25 40 20 35 18 11 38 45 58 31 45 67 Decrease-key(Q,I,7)

2 I 15 5 17 25 40 20 35 18 11 38 45 58 7 45 Need parent pointers (not needed before) 67

2 I 15 5 17 25 40 7 35 18 11 38 45 58 20 45 67 Need to update the node pointed by I

2 I 7 5 17 25 40 15 35 18 11 38 45 58 20 45 67 How can we do it?

Adding parent pointers
Q Adding parent pointers n first min 23 9 15 33 40 20 35 45 58 31 67

Adding a level of indirection
Q Adding a level of indirection n “Endogenous vs. exogenous” first min 23 9 15 item child next x parent node info key I 33 40 20 35 45 58 31 Nodes and items are distinct entities 67

Fibonacci Heaps Lazy Binomial Heaps Binomial Heaps Binary Heaps O(1) O(log n) Insert Find-min Delete-min Decrease-key – Meld Worst case Amortized

Lazy Binomial Heaps

Binomial Heaps Lazy Binomial Heaps
A list of binomial trees, at most one of each rank, sorted by rank (at most O(log n) 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

Lazy Binomial Heaps An arbitrary list of binomial trees
Pointer to root with minimal key 10 29 9 33 59 45 67 40 58 20 31 15 35 87 19 20

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

Lazy Delete-min ? Remove the minimum root and meld ?
10 29 15 33 59 9 19 20 40 20 35 45 58 31 67 May need (n) time to find the new minimum

Consolidating / Successive Linking
10 29 15 59 40 20 35 19 33 45 58 31 20 67 … 1 2 3

29 15 59 40 20 35 19 33 45 58 31 20 67 … 10 1 2 3

15 59 40 20 35 19 33 45 58 31 20 67 10 … 29 1 2 3

59 40 20 35 19 45 58 31 20 67 10 15 29 … 33 1 2 3

40 20 35 19 45 58 31 20 67 10 15 29 … 59 33 1 2 3

20 35 19 31 20 45 67 40 58 15 33 10 29 … 59 1 2 3

35 19 20 45 67 40 58 15 33 10 29 … 20 59 31 1 2 3

19 20 35 45 67 40 58 15 33 10 29 59 … 20 31 1 2 3

19 20 45 67 40 58 15 33 10 29 20 35 31 … 59 1 2 3

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 67 40 58 15 33 10 29 20 35 31 … 19 20 59 1 2 3

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 – O(log n) Potential = Number of Trees

Cost of Consolidating T0 – Number of trees before
T1 – Number of trees after L – Number of links T1 = T0−L (Each link reduces the number of tree by 1) Total number of trees processed – T0+L (Each link creates a new tree) Putting trees into buckets or finding trees to link with Linking Handling the buckets Total cost = O( (T0+L) + L + log2n ) = O( T0+ log2n ) As L ≤ T0

Amortized Cost of Consolidating
(Scaled) actual cost = T0 + log2n Change in potential =  = T1−T0 Amortized cost = (T0 + log2n ) + (T1−T0)  = T1 + log2n  ≤ log2n As T1 ≤ log2n 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.

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

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 – O(log n) Potential = Number of Trees Exercise: Prove it!

One-pass successive Linking
10 29 15 59 40 20 35 19 33 45 58 31 20 67 … 1 2 3

29 15 59 40 20 35 19 33 45 58 31 20 67 … 10 1 2 3

15 59 40 20 35 19 33 45 58 31 20 67 … 1 2 3 10 Output list: 29

Fibonacci Heaps [Fredman-Tarjan (1987)]

Decrease-key in O(1) time?
2 x 15 5 17 25 40 20 35 18 11 38 45 58 31 45 Decrease-key(Q,x,30) 67

2 x 15 5 17 25 30 20 35 18 11 38 45 58 31 45 Decrease-key(Q,x,10) 67

2 x 15 5 17 25 10 20 35 18 11 38 45 58 31 45 67 Heap order violation

2 x 15 5 17 25 10 20 35 18 11 38 45 58 31 45 67 Cut the edge

2 x 15 5 17 25 10 20 35 18 11 38 45 58 31 45 67 Tree no longer binomial

Fibonacci Heaps A list of heap-ordered trees
Pointer to root with minimal key 10 29 9 59 87 15 19 25 22 33 40 20 35 58 31 Not all trees may appear in Fibonacci heaps

Fibonacci heap representation
Q min 1 3 23 9 15 2 33 40 20 35 Explicit ranks = degrees Doubly linked lists of children 1 45 58 Arbitrary order of children child points to an arbitrary child 67 4 pointers + rank + mark bit per node

Fibonacci heap representation
Q min 1 x info rank child next prev parent mark key 3 23 9 15 2 33 40 20 35 1 45 58 67 4 pointers + rank + mark bit per node

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

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

Our convention: Roots are unmarked
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

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

Cascading cuts … … …

Cascading cuts … …

Number of cuts Potential = Number of marked nodes
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

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

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

Lemma 3: A node of rank k in a Fibonacci Heap has at least Fk+2 ≥ k descendants, including itself. n 1 2 3 4 5 6 7 8 9 Fn 13 21 34

Lemma 3: A node of rank k in a Fibonacci Heap has at least Fk+2 ≥ k descendants, including itself. Let Sk be the minimum number of descendants of a node of rank at least k … k k3 k2 1

Lemma 3: A node of rank k in a Fibonacci Heap has at least Fk+2 ≥ k descendants, including itself. Corollary: In a Fibonacci heap containing n items, all ranks are at most logn ≤ log2n Ranks are again O(log n) Are we done?

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

T1 – Number of trees after L – Number of links T1 = T0−L (Each link reduces the number of tree by 1) Total number of trees processed – T0+L (Each link creates a new tree) Putting trees into buckets or finding trees to link with Linking Handling the buckets Total cost = O( (T0+L) + L + logn ) = O( T0+ logn ) As L ≤ T0

T1 – Number of trees after L – Number of links T1 = T0−L (Each link reduces the number of tree by 1) Total number of trees processed – T0+L (Each link creates a new tree) Only change: logn instead of log2n Total cost = O( (T0+L) + L + logn ) = O( T0+ logn ) As L ≤ T0

Number of cuts performed
Fibonacci heaps Amortized cost  Marks  Trees Actual cost O(1) 1 Insert Find-min O(log n) ≤ 0 k1+T1−T0 O(k+T0+log n) Delete-min ≤ 2c c O(c) Decrease-key Meld Rank of deleted root Number of cuts performed

Consolidating / Successive linking

Data Structures Binomial Heaps Fibonacci Heaps Haim Kaplan & Uri Zwick

Similar presentations

Presentation on theme: "Data Structures Binomial Heaps Fibonacci Heaps Haim Kaplan & Uri Zwick"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Data Structures Binomial Heaps Fibonacci Heaps Haim Kaplan & Uri Zwick

Similar presentations

Presentation on theme: "Data Structures Binomial Heaps Fibonacci Heaps Haim Kaplan & Uri Zwick"— Presentation transcript:

Similar presentations

About project

Feedback