Data Structures Binomial Heaps Fibonacci HeapsFibonacci Heaps A list of heap-ordered trees 29 59 87...

Data Structures

Haim Kaplan & Uri Zwick

December 2013

Binomial Heaps

Fibonacci Heaps

Fibonacci

Binomial

Binary

O(1) O(1) O(log n) O(log n) Insert

O(1) O(1) O(1) O(1) Find-min

O(log n) O(log n) O(log n) O(log n) Delete-min

O(1) O(log n) O(log n) O(log n) Decrease-key

O(1) O(1) O(log n) – Meld

Heaps / Priority queues

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

Binomial Trees

B0 B1 B2 B3

Binomial Trees

B0 B1 B2 B3

Bk−1

Bk−1 Bk−1 Bk−2

Binomial Trees

Bk−1

Bk−1 Bk−2

Min-heap Ordered Binomial Trees

key of child key of parent

Tournaments Binomial Trees

B H C E D F

D G F A

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

Each number n can be written

in a unique way as a sum of

powers of 2

11 = (1011)2 = 8+2+1

At most

log2 (n+1) trees

Ordered forest Binary tree

next – next “sibling”

info key

child next

2 pointers per node

child – leftmost child

Forest Binary tree

67 58 31 35

Heap order

“half ordered”

Binomial heap representation

n first

2 pointers per node

No explicit rank information

info key

child next

“Structure V”

[Brown (1978)]

How do we determine ranks?

Alternative representation

n first

Reverse sibling pointers

Make lists circular

min Avoids reversals during meld

“Structure R”

[Brown (1978)]

info key

child next

Bk−1

Linking binomial trees

a ≤ b

O(1) time

Linking in first

representation

Linking in second

representation

Linking binomial trees

Melding binomial heaps

Link trees of same degree

Q1: B0 B1 B3

Q2: B0 B2 B3

Melding binomial heaps Link trees of same degree

B1 B2 B3

Like adding binary numbers

O(log n) time

Maintain a pointer to the minimum

Insert

New item is a one tree binomial heap

Meld it to the original heap

O(log n) time

Delete-min

When we delete the

minimum, we get a

binomial heap

Delete-min

When we delete the

minimum, we get a

binomial heap

Meld it to the original heap

O(log n) time

(Need to reverse list of

roots in first representation)

Decrease-key using “sift-up”

Decrease-key(Q,I,7)

Need parent pointers

(not needed before)

Need to update the node pointed by I

How can we do it?

Adding parent pointers

n first

item child next

parent

Adding a level of indirection

info key

Nodes and items

are distinct entities

n first

“Endogenous vs. exogenous”

Fibonacci

Binomial

Binary

O(1) O(1) O(1) O(1) Find-min

Lazy Binomial Heaps

Binomial Heaps

A list of binomial trees,

at most one of each rank, sorted by rank

(at most O(log n) trees)

Lazy Binomial Heaps

An arbitrary list of binomial trees

(possibly n trees of size 1)

Lazy Binomial Heaps

An arbitrary list of binomial trees

29 59 87 19

Update the pointer to root with minimal key

Lazy Meld

Concatenate the two lists of trees

O(1) worst case time

Update the pointer to root with minimal key

Lazy Insert

Add the new item to the list of roots

O(1) worst case time

May need (n) time to find the new minimum

Lazy Delete-min ?

Remove the minimum root and meld ?

10 29 59 19

Consolidating / Successive Linking

10 29 59 19

29 59 19

35 59 19

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

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

L – Number of links

T1 – Number of trees after

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)

Total cost = O( (T0+L) + L + log2n )

= O( T0+ log2n )

Putting trees into buckets

or finding trees to link with Linking

Handling

the buckets

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

≤ 2 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.

Amortized

Change in

potential Actual cost

O(1) 1 O(1) Insert

O(1) 0 O(1) Find-min

O(log n) k1+T1−T0 O(k+T0+log n) Delete-min

O(log n) 0 O(log n) Decrease-key

O(1) 0 O(1) Meld

Lazy Binomial Heaps

Rank of

deleted root

Fibonacci

Binomial

Binary

O(1) O(1) O(1) O(1) Find-min

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!

10 29 59 19

One-pass successive Linking

29 59 19

One-pass successive Linking

Output list:

Fibonacci Heaps [Fredman-Tarjan (1987)]

Decrease-key in O(1) time?

Decrease-key(Q,x,30)

Decrease-key(Q,x,10)

Heap order violation

Cut the edge

Tree no longer binomial

Fibonacci Heaps

A list of heap-ordered trees

29 59 87 19

Not all trees may appear in Fibonacci heaps

Fibonacci heap representation

4 pointers + rank + mark bit per node

Doubly linked lists of children

Arbitrary order of children

child points to an arbitrary child

Explicit ranks = degrees

Fibonacci heap representation

4 pointers + rank + mark bit per node

child next prev

parent

Are simple cuts enough?

Ranks not necessarily O(log n)

A binomial tree of rank k

contains at least 2k

We may get trees of rank k

containing only k+1 nodes

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

Cascading cuts

Invariant: Each node looses at most

one child after becoming a child itself

When xy 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

Cascading cuts

Cut x from its parent y

Perform a cascading-cut

process starting at x

Cascading cuts

… …

Cascading cuts

… …

Cascading cuts

… …

Cascading cuts

… …

Cascading cuts

… …

Cascading cuts

… …

Cascading cuts

… …

Cascading cuts

… …

Number of cuts

A decrease-key operation may trigger many 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

Lemma 1: The first d decrease-key

operations trigger at most 2d cuts

Potential = Number of marked nodes

Number of cuts

Potential = Number of marked nodes

Amortized

number of cuts ≤ c + (1(c1)) = 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 i2.

Proof: When yi was linked to x,

y1,…yi1 were already children of x.

At that time, the rank of x and yi was at least i1.

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 0 1 2 3 4 5 6 7 8 9

Fn 0 1 1 2 3 5 8 13 21 34

Let Sk be the minimum

number of descendants of a

node of rank at least k

Corollary: In a Fibonacci heap containing n items,

all ranks are at most logn ≤ 1.4404 log2n

Ranks are again O(log n)

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

Putting it all together

Are we done?

Potential = #trees + 2 #marked

Total cost = O( (T0+L) + L + logn )

= O( T0+ logn )

Putting trees into buckets

or finding trees to link with Linking

Handling

the buckets

As L ≤ T0

Total cost = O( (T0+L) + L + logn )

= O( T0+ logn )

Only change:

logn instead of log2n

As L ≤ T0

Amortized

cost Marks Trees Actual cost

O(1) 0 1 O(1) Insert

O(1) 0 0 O(1) Find-min

O(log n) ≤ 0 k1+T1−T0 O(k+T0+log n) Delete-min

O(1) ≤ 2c c O(c) Decrease-

O(1) 0 0 O(1) Meld

Fibonacci heaps

Rank of

deleted root Number of cuts

performed

Fibonacci

Binomial

Binary

O(1) O(1) O(1) O(1) Find-min

Consolidating / Successive linking

Data Structures Binomial Heaps Fibonacci HeapsFibonacci Heaps A list of heap-ordered trees 29 59 87...

Documents

Binomial heaps, Fibonacci heaps, and applications

Lab 2. Binomial Heaps and Fibonacci Heaps

Fibonacci Heaps - 臺灣大學計算機中心ccf.ee.ntu.edu.tw/~yen/courses/ds19/chapter-5c.pdf · 2019-05-05 · Fibonacci Heaps Fibonacci heap history. Fredman and Tarjan (1986)

Amortized Analysisluc.devroye.org/ArielGoodwin+MalcolmSutcliffe-AmortizedAnalysis-McGillUniversity-2020.pdfamortized analysis 7 Example 5.Fibonacci Heaps The Fibonacci heap was conceived

CMSC 341 Binomial Queues and Fibonacci Heaps. Basic Heap Operations OpBinary Heap Leftist Heap Binomial Queue Fibonacci Heap insertO(lgN) deleteMinO(lgN)

Fibonacci Heaps Priority Queues - Purdue Universitycs180/Spring2010Web/... · 2010. 4. 26. · Heap 1 Linked List 1 Fibonacci Heap † insert e n log n log n 1 n y 1 1 1 log n 1-decrease-key

binary heaps d-ary heaps binomial heaps Fibonacci heapswds/classes/aa/KT/BinomialHeaps.pdfTheorem. Given n elements, can construct a binary heap containing those n elements in O(n)

19 Fibonacci Heaps - Khoury College of Computer Sciences€¦ · 19 Fibonacci Heaps The Fibonacci heap data structure serves a dual purpose. First, it supports a set of operations

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

Dijkstra's Algorithm with Fibonacci Heaps: An Executable … · Introduction Single-source shortest path Fibonacci Heaps Performance Conclusion Dijkstra’s Algorithm with Fibonacci

Fibonacci Heaps and Binary Heaps

16 Fibonacci Heaps

Binomial and Fibonacci Heaps

Heaps de Fibonacci Lino Alves. Heap de Fibonacci

Fibonacci Heaps and Their Uses in Improved Network … · 2012. 10. 24. · Fibonacci Heaps and Improved Network Optimization Algorithms 597 1. Introduction A heap is an abstract

Introduction Fibonacci Heap Time Complexity Analysisbasics.sjtu.edu.cn/.../2016-12-08-fibonacci-heaps-Minus-One-Second.… · Fibonacci Heap Time Complexity Analysis Amortized Analysis

08 Fibonacci Heaps

Algorithmentheorie 15 – Fibonacci-Heaps

Fibonacci Heap(HF)

Fibonacci Heaps