Fibonacci Heap

Fibonacci Heaps
These lecture slides are adapted

from CLRS, Chapter 20.
Princeton University COS 423 Theory of Algorithms Spring 2002 Kevin Wayne
Priority Queues
Heaps
Operation
Linked List
Binary
Binomial
Fibonacci
Relaxed
make-heap
insert
log N
log N
find-min
log N
delete-min
log N
log N
log N
log N
union
log N
decrease-key
log N
log N
delete
log N
log N
log N
log N
is-empty
amortized
this time
Fibonacci Heaps
Fibonacci heap history. Fredman and Tarjan (1986)
Ingenious data structure and analysis.

Original motivation: O(m + n log n) shortest path algorithm.
also led to faster algorithms for MST, weighted bipartite matching
Still ahead of its time.
Fibonacci heap intuition.
Similar to binomial heaps, but less structured.
Decrease-key and union run in O(1) time.
"Lazy" unions.
Fibonacci Heaps: Structure

Fibonacci heap.
Set of min-heap ordered trees.
min
17
30
24
26
35
23
46
marked
18
39
52
41
44
Fibonacci Heaps: Implementation

Implementation.
Represent trees using left-child, right sibling pointers and circular,

doubly linked list.
can quickly splice off subtrees
Roots of trees connected with circular doubly linked list.
fast union
Pointer to root of tree with min element.
fast find-min
min
17
30
24
26
35
23
46
18
39
52
41
44
Fibonacci Heaps: Potential Function

Key quantities.
Degree[x] = degree of node x.
Mark[x] = mark of node x (black or gray).
t(H) = # trees.
m(H) = # marked nodes.
(H) = t(H) + 2m(H) = potential function.

t(H) = 5, m(H) = 3
(H) = 11
17
30
24
26
35
degree = 3
23
46
18
min
39
52
41
44
Fibonacci Heaps: Insert

Insert.
Create a new singleton tree.
Add to left of min pointer.
Update min pointer.
Insert 21
21
17
30
24
26
35
23
46
min
18
39
52
41
44

Insert.
Update min pointer.
Insert 21
min
17
30
24
26
35
23
46
21
18
39
52
41
44

Insert.
Update min pointer.
Running time. O(1) amortized
Actual cost = O(1).
Change in potential = +1.
Amortized cost = O(1).
17
30
24
26
35
Insert 21
min
23
46
21
18
39
52
41
44
Fibonacci Heaps: Union

Union.
Concatenate two Fibonacci heaps.
Root lists are circular, doubly linked lists.
min
23
H'
30
24
26
35
46
17
min
18
39
52
21
41
44
H'
'
Fibonacci Heaps: Union

Union.
Concatenate two Fibonacci heaps.
Root lists are circular, doubly linked lists.
Running time. O(1) amortized
Actual cost = O(1).
Change in potential = 0.
Amortized cost = O(1).

min
23
H'
30
24
26
35
46
17
18
39
52
21
41
44
H'
'
Fibonacci Heaps: Delete Min

Delete min.
Delete min and concatenate its children into root list.
Consolidate trees so that no two roots have same degree.
min
7
30
24
26
35
46
23
17
18
39
52
41
44

Delete min.
min
current
30
24
26
35
46
23
17
18
39
52
41
44

Delete min.
min
current
30
24
26
35
46
23
17
18
39
52
41
44

Delete min.
current
min
7
30
24
26
35
46
23
17
18
39
52
41
44

Delete min.
min
7
30
26
35
24
23
46
current
17
18
39
52
41
44

Delete min.
min
7
30
24
26
46
23
17
18
current
52
39
35
Merge 17 and 23 trees.
41
44

Delete min.
current
min
7
30
26
24
17
18
46
23
39
52
35
41
44

Delete min.
current
min
24
26
35
46
17
18
30
39
52
23
41
44

Delete min.
current
min
26
35
24
17
46
23
18
30
39
52
41
44

Delete min.
current
min
26
35
24
17
46
23
18
30
39
52
41
44

Delete min.
current
min
26
35
24
17
46
23
18
30
39
52
41
44

Delete min.
current
min
26
24
17
46
23
18
30
39
52

35
41
44

Delete min.
current
min
7
26
35
24
17
46
23
30
52
18
41
44
39

Delete min.
current
min
7
26
35
24
17
46
23
30
52
18
41
44
39

Delete min.
min
7
26
24
17
46
23
52
41
30
44
Stop.
35
18
39
Fibonacci Heaps: Delete Min Analysis

Notation.
D(n) = max degree of any node in Fibonacci heap with n nodes.
t(H) = # trees in heap H.
(H) = t(H) + 2m(H).
Actual cost. O(D(n) + t(H))
O(D(n)) work adding min's children into root list and updating min.
at most D(n) children of min node
O(D(n) + t(H)) work consolidating trees.
work is proportional to size of root list since number of roots
decreases by one after each merging
D(n) + t(H) - 1 root nodes at beginning of consolidation
Amortized cost. O(D(n))
t(H') D(n) + 1 since no two trees have same degree.
(H) D(n) + 1 - t(H).
Fibonacci Heaps: Delete Min Analysis

Is amortized cost of O(D(n)) good?
Yes, if only Insert, Delete-min, and Union operations supported.

in this case, Fibonacci heap contains only binomial trees since
we only merge trees of equal root degree
this implies D(n) log2 N
Yes, if we support Decrease-key in clever way.
we'll show that D(n) log N , where is golden ratio
2 = 1 +
= (1 + 5) / 2 = 1.618
limiting ratio between successive Fibonacci numbers!
Fibonacci Heaps: Decrease Key

Decrease key of element x to k.
Case 0: min-heap property not violated.

decrease key of x to k
change heap min pointer if necessary
min
7
35
24
17
26
46
45
30
88
72
23
21
18
38
39
41
52
Decrease 46 to 45.

Case 1: parent of x is unmarked.

cut off link between x and its parent
mark parent
add tree rooted at x to root list, updating heap min pointer
min
7
35
24
17
26
45
15
30
88
72
23
21
18
38
39
41
52
Decrease 45 to 15.


mark parent
min
7
35
24
17
26
15
30
88
72
23
21
18
38
39
41
52
Decrease 45 to 15.


mark parent
min
15
72
24
26
35
88
17
30
23
21
18
38
39
41
52
Decrease 45 to 15.

Case 2: parent of x is marked.

cut off link between x and its parent p[x], and add x to root list
cut off link between p[x] and p[p[x]], add p[x] to root list
If p[p[x]] unmarked, then mark it.
If p[p[x]] marked, cut off p[p[x]], unmark, and repeat.
min
15
72
24
26
35
5
88
17
30
23
21
18
38
39
41
52
Decrease 35 to 5.


min
15
72
parent marked
24
26
88
17
30
23
21
18
38
39
41
52
Decrease 35 to 5.


min
15
72
26
88
24
17
parent marked30
23
21
18
38
39
41
52
Decrease 35 to 5.


min
15
72
26
88
24
17
30
23
21
18
38
39
41
52
Decrease 35 to 5.
Fibonacci Heaps: Decrease Key Analysis

Notation.
t(H)
= # trees in heap H.
m(H) = # marked nodes in heap H.
(H) = t(H) + 2m(H).
Actual cost. O(c)
O(1) time for decrease key.
O(1) time for each of c cascading cuts, plus reinserting in root list.
Amortized cost. O(1)
t(H') = t(H) + c
m(H') m(H) - c + 2
each cascading cut unmarks a node
last cascading cut could potentially mark a node
c + 2(-c + 2) = 4 - c.
Fibonacci Heaps: Delete

Delete node x.
Decrease key of x to -.
Delete min element in heap.
Amortized cost. O(D(n))
O(1) for decrease-key.
O(D(n)) for delete-min.
D(n) = max degree of any node in Fibonacci heap.
Fibonacci Heaps: Bounding Max Degree

Definition. D(N) = max degree in Fibonacci heap with N nodes.
Key lemma. D(N) log N, where = (1 + 5) / 2.
Corollary. Delete and Delete-min take O(log N) amortized time.
Lemma. Let x be a node with degree k, and let y1, . . . , yk denote the children
of x in the order in which they were linked to x. Then:
if i 1
0
i 2 if i 1
degree ( yi )
Proof.
When yi is linked to x, y1, . . . , yi-1 already linked to x,

degree(x) = i - 1
degree(yi) = i - 1 since we only link nodes of equal degree
Since then, yi has lost at most one child
otherwise it would have been cut from x
Thus, degree(yi) = i - 1 or i - 2
Fibonacci Heaps: Bounding Max Degree

Key lemma. In a Fibonacci heap with N nodes, the maximum degree of
any node is at most log N, where = (1 + 5) / 2.
Proof of key lemma.
For any node x, we show that size(x) degree(x) .

size(x) = # node in subtree rooted at x
taking base logs, degree(x) log (size(x)) log N.
Let sk be min size of tree rooted at any degree k node.
trivial to see that s0 = 1, s1 = 2
sk monotonically increases with k
Let x* be a degree k node of size sk,

and let y1, . . . , yk be children in order
that they were linked to x*.
Assume k 2
sk
size ( x*)
k
2 size ( yi )
i 2
k
2 sdeg[ y ]
i 2
k
2 si 2
i 2
k 2
2 si
i 0
Fibonacci Facts
Definition. The Fibonacci sequence is:
1, 2, 3, 5, 8, 13, 21, . . .
Slightly nonstandard definition.
Fk 2
F F
k -2
k -1
if k 0
if k 1
if k 2
Fact F1. Fk k, where = (1 + 5) / 2 = 1.618
Fact F2.
k 2
For k 2, Fk 2 Fi
i 0
sk
size ( x*)
k
2 size ( yi )
Consequence. sk Fk
k.
This implies that size(x) degree(x)

for all nodes x.
i 2
k
2 sdeg[ y ]
i 2
k
2 si 2
i 2
k 2
2 si
i 0
Golden Ratio
Definition. The Fibonacci sequence is: 1, 2, 3, 5, 8, 13, 21, . . .
Definition. The golden ratio = (1 + 5) / 2 = 1.618
Divide a rectangle into a square and smaller rectangle such that the
smaller rectangle has the same ratio as original one.
Parthenon, Athens Greece
Fibonacci Facts
Fibonacci Numbers and Nature
Pinecone
Cauliflower
Fibonacci Proofs
Fact F1. Fk k.
Proof. (by induction on k)
Fk 2
Base cases:
F0 = 1, F1 = 2 .
Fk Fk 1
k k 1
k (1 )
k ( 2 )
k 2
Inductive hypotheses:
Fk k and Fk+1 k+1
2 = + 1
k 2
Fact F2. For k 2, Fk 2 Fi

i 0
Proof. (by induction on k)
Base cases:
F2 = 3, F3 = 5
Fk 2
Fk Fk 1
k 2
2 Fi Fk 1
Inductive hypotheses:
k 2
Fk 2 Fi
i 0
i 0
k
2 Fk
i 0
On Complicated Algorithms
"Once you succeed in writing the programs for [these] complicated
algorithms, they usually run extremely fast. The computer doesn't
need to understand the algorithm, its task is only to run the
programs."
R. E. Tarjan

Fibonacci Heap

Uploaded by

Copyright:

Available Formats

Fibonacci Heap

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Fibonacci Heap

Uploaded by

Copyright:

Available Formats

Fibonacci Heaps

These lecture slides are adapted

Ingenious data structure and analysis.

Fibonacci heap intuition.

Similar to binomial heaps, but less structured.

Decrease-key and union run in O(1) time.

Fibonacci Heaps: Structure

Set of min-heap ordered trees.

Fibonacci Heaps: Implementation

Represent trees using left-child, right sibling pointers and circular,

Fibonacci Heaps: Potential Function

Degree[x] = degree of node x.

Mark[x] = mark of node x (black or gray).

m(H) = # marked nodes.

(H) = t(H) + 2m(H) = potential function.

Fibonacci Heaps: Insert

Create a new singleton tree.

Add to left of min pointer.

Update min pointer.

Fibonacci Heaps: Insert

Create a new singleton tree.

Add to left of min pointer.

Update min pointer.

Fibonacci Heaps: Insert

Create a new singleton tree.

Add to left of min pointer.

Update min pointer.

Running time. O(1) amortized

Actual cost = O(1).

Change in potential = +1.

Amortized cost = O(1).

Fibonacci Heaps: Union

Concatenate two Fibonacci heaps.

Root lists are circular, doubly linked lists.

Fibonacci Heaps: Union

Concatenate two Fibonacci heaps.

Root lists are circular, doubly linked lists.

Running time. O(1) amortized

Actual cost = O(1).

Amortized cost = O(1).

Fibonacci Heaps: Delete Min

Delete min and concatenate its children into root list.

Consolidate trees so that no two roots have same degree.

Fibonacci Heaps: Delete Min

Delete min and concatenate its children into root list.

Consolidate trees so that no two roots have same degree.

Fibonacci Heaps: Delete Min

Delete min and concatenate its children into root list.

Consolidate trees so that no two roots have same degree.

Fibonacci Heaps: Delete Min

Delete min and concatenate its children into root list.

Consolidate trees so that no two roots have same degree.

Fibonacci Heaps: Delete Min

Delete min and concatenate its children into root list.

Consolidate trees so that no two roots have same degree.

Fibonacci Heaps: Delete Min

Delete min and concatenate its children into root list.

Consolidate trees so that no two roots have same degree.

Merge 17 and 23 trees.