Question

The Fibonacci heap data structure has the word “Fibonacci” in its name, but nothing in the data structure seems to use Fibonacci numbers. According to the Wikipedia article:

The name of Fibonacci heap comes from Fibonacci numbers which are used in the running time analysis.

How do these Fibonacci numbers arise in the Fibonacci heap?

Answer 1

The Fibonacci heap is made up of a collection of smaller heap-ordered trees of different “orders” that obey certain structural constraints. The Fibonacci sequence arises because these trees are constructed in a way such that a tree of order n has at least F_n+2 nodes in it, where F_n+2 is the (n + 2)nd Fibonacci number.

To see why this result is true, let’s begin by seeing how the trees in the Fibonacci heap are constructed. Initially, whenever a node is put into a Fibonacci heap, it is put into a tree of order 0 that contains just that node. Whenever a value is removed from the Fibonacci heap, some of the trees in the Fibonacci heap are coalesced together such that the number of trees doesn’t grow too large.

When combining trees together, the Fibonacci heap only combines together trees of the same order. To combine two trees of order n into a tree of order n + 1, the Fibonacci heap takes whichever of the two trees has a greater root value than the other, then makes that tree a child of the other tree. One consequence of this fact is that trees of order n always have exactly n children.

The main attraction of the Fibonacci heap is that it supports the decrease-key efficiently (in amortized O(1)). In order to support this, the Fibonacci heap implements decrease-key as follows: to decrease the key of a value stored in some node, that node is cut from its parent tree and treated as its own separate tree. When this happens, the order of its old parent node is decreased by one. For example, if an order 4 tree has a child cut from it, it shrinks to an order 3 tree, which makes sense because the order of a tree is supposed to be the number of children it contains.

The problem with doing this is that if too many trees get cut off from the same tree, we might have a tree with a large order but which contains a very small number of nodes. The time guarantees of a Fibonacci heap are only possible if trees with large orders contain a huge number of nodes, and if we can just cut any nodes we’d like from trees we could easily get into a situation where a tree with a huge order only contains a small number of nodes.

To address this, Fibonacci heaps make one requirement – if you cut two children from a tree, you have to in turn cut that tree from its parent. This means that the trees that form a Fibonacci heap won’t be too badly damaged by decrease-key.

And now we can get to the part about Fibonacci numbers. At this point, we can say the following about the trees in a Fibonacci heap:

• A tree of order n has exactly n children.
• Trees of order n are formed by taking two trees of order n – 1 and making one the child of another.
• If a tree loses two children, that tree is cut away from its parent.

So now we can ask – what are the smallest possible trees that you can make under these assumptions?

Let’s try out some examples. There is only one possible tree of order 0, which is a just a single node:

Smallest possible order 0 tree:      *

The smallest possible tree of order 1 would have to be at least a node with a child. The smallest possible child we could make is a single node with the smallest order-0 tree as a child, which is this tree:

Smallest possible order 1 tree:      *
                                     |
                                     *

What about the smallest tree of order 2? This is where things get interesting. This tree certainly has to have two children, and it would be formed by merging together two trees of order 1. Consequently, the tree would initially have two children – a tree of order 0 and a tree of order 1. But remember – we can cut away children from trees after merging them! In this case, if we cut away the child of the tree of order 1, we would be left with a tree with two children, both of which are trees of order 0:

Smallest possible order 2 tree:      *
                                    / \
                                   *   *

How about order 3? As before, this tree would be made by merging together two trees of order 2. We would then try to cut away as much of the subtrees of this order-3 tree as possible. When it’s created, the tree has subtrees of orders 2, 1, and 0. We can’t cut away from the order 0 tree, but we can cut a single child from the order 2 and order 1 tree. If we do this, we’re left with a tree with three children, one of order 1, and two of order 2:

 Smallest possible order 3 tree:       *
                                      /|\
                                     * * *
                                     |
                                     *

Now we can spot a pattern. The smallest possible order-(n + 2) tree would be formed as follows: start by creating a normal order (n + 2) tree, which has children of orders n + 1, n, n – 1, …, 2, 1, 0. Then, make those trees as small as possible by cutting away nodes from them without cutting two children from the same node. This leaves a tree with children of orders n, n – 2, …, 1, 0, and 0.

We can now write a recurrence relation to try to determine how many nodes are in these trees. If we do this, we get the following, where NC(n) represents the smallest number of nodes that could be in a tree of order n:

NC(0) = 1
NC(1) = 2
NC(n + 2) = NC(n) + NC(n - 1) + ... + NC(1) + NC(0) + NC(0) + 1

Here, the final +1 accounts for the root node itself.

If we expand out these terms, we get the following:

NC(0) = 1
NC(1) = 2
NC(2) = NC(0) + NC(0) + 1 = 3
NC(3) = NC(1) + NC(0) + NC(0) + 1 = 5
NC(4) = NC(2) + NC(1) + NC(0) + NC(0) + 1 = 8

If you’ll notice, this is exactly the Fibonacci series offset by two positions. In other words, each of these trees has to have at least F_n+2 nodes in them, where F_{n + 2} is the (n + 2)nd Fibonacci number.

So why is it called a Fibonacci heap? Because each tree of order n has to have at least F_n+2 nodes in it!

If you’re curious, the original paper on Fibonacci heaps has pictures of these smallest possible trees. It’s pretty nifty to see! Also, check out this CS Theory Stack Exchange Post for an alternative explanation as to why Fibonacci heap trees have the sizes they do.

Hope this helps!