2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement 

DS Tutorial

DS Tutorial

DS Introduction

DS Algorithm

Asymptotic Analysis

DS Pointer

DS Structure

DS Array

DS Array

2D Array

DS Linked List

Linked List

Types of Linked List

Singly Linked List

Doubly Linked List

Circular Linked List

Circular Doubly List

Skip list in DS

https://www.tpointtech.com/fibonacci-heap 1/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

DS Stack
Advertisement

DS Stack

Array Implementation

Linked List Implementation

Javatpoint.com is now
TpointTech.com
Javatpoint.com is now changed to TpointTech.com, so we
request you to subscribe our newsletter for further updates.

Your Email Subscribe 

← prev next →

Fibonacci Heap
In this article, we will learn about the Fibonacci heap, its properties, advantages and,
later on, its implementation: Before discussing the Fibonacci heap, let us first take a
quick overview of ideas used in building a Fibonacci heap:

What are heaps in data structure?

Heaps are the abstract data type which is used to show the relationship between parents
and children: Heap is categorized into Min-Heap and Max-Heap:

1. A min-heap is a tree in which, for all the nodes, the key value of the parent must be
smaller than the key value of the children.
2. A max-heap is a tree in which, for all the nodes, the key value of the parent must be
greater than the key value of the children.

What is a circular doubly-linked list in data structure?

https://www.tpointtech.com/fibonacci-heap 2/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

A doubly-linked list is the advanced version of the singly-linked list. Each node in a
double-linked list contains two pointers left and right pointers. The left-pointer points to
its left node, and the right-pointer points to the right node. The right pointer of the last
node points to the first node, and the left pointer of the first node points to the last node.
The figure shows how a circular doubly-linked list is observed:

Let us now discuss the Fibonacci heap:

Define Fibonacci Heap:

Fibonacci Heap - A Fibonacci heap is defined as the collection of rooted-tree in which all
the trees must hold the property of Min-heap. That is, for all the nodes, the key value of
the parent node should be greater than the key value of the parent node:

The given figure is an example of the Fibonacci tree:

The above Fibonacci Heap consists of five rooted min-heap-ordered trees with 14 nodes.
The min-heap-ordered tree means the tree which holds the property of a min-heap. The
dashed line shows the root list. The minimum node in the Fibonacci heap is the node
containing the key = 3 pointed by the pointer FH-min.

https://www.tpointtech.com/fibonacci-heap 3/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Here, 18, 39, 26, and 35 are marked nodes, meaning they have lost one child. The
potential of theAdvertisement
Fibonacci series = No. of rooted tree + Twice the number of marked
nodes = 5 + 2 * 4 = 13.

Let us now observe the above example with the complete representation of the
Fibonacci Heap:

In the above figure, we can observe that each node contains four pointers, the parent
points to the parent (Upward), the child points to the child (downward), and the left and
right pointers for the siblings (sideways).

Properties of Fibonacci Heap:

1. It can have multiple trees of equal degrees, and each tree doesn't need to have 2^k nodes.
2. All the trees in the Fibonacci Heap are rooted but not ordered.
3. All the roots and siblings are stored in a separated circular-doubly-linked list.
4. The degree of a node is the number of its children. Node X -> degree = Number of X's
children.
5. Each node has a mark-attribute in which it is marked TRUE or FALSE. The FALSE indicates
the node has not any of its children. The TRUE represents that the node has lost one child.
The newly created node is marked FALSE.
6. The potential function of the Fibonacci heap is F(FH) = t[FH] + 2 * m[FH]
7. The Fibonacci Heap (FH) has some important technicalities listed below:
1. min[FH] - Pointer points to the minimum node in the Fibonacci Heap
2. n[FH] - Determines the number of nodes
3. t[FH] - Determines the number of rooted trees
4. m[FH] - Determines the number of marked nodes
5. F(FH) - Potential Function.

The time complexities of different operations performed on a Fibonacci heap are listed
below in the table:

https://www.tpointtech.com/fibonacci-heap 4/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

1. Find Min Q (1) Binary and

Advertisement
Binomial heaps
have the same
time complexity.

2. Extract Min O(D(n)) = O(log n) Binary and

Binomial heaps
have the same
time complexity.

3. Delete a Node Q (1) Binary takes

O(logn) and
Binomial takes Q
(1)

4. Decrease Key Q (1) Binary and

Binomial both
take O(logn)

5. Union Q (1) Binarytakese O(m

logn) or O(m+n)
and Binomial
takes O(logn).

1. Creating a Fibonacci Heap:

In an empty Fibonacci Heap (FH)

The number of rooted trees, t(FH) = zero,

The minimum node, FH -> min = NIL,

Number of nodes, FH -> n = 0,

Number of marked nodes, FH -> m = 0, and

The potential of the empty Fibonacci heap ?(FH) = 0.

It is created by the MAKE-FIB-HEAP, which allocates and returns the Fibonacci heap
object, FH in amortized cost O(1) equal to its actual cost:


https://www.tpointtech.com/fibonacci-heap 5/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint
Home Python Java JavaScript HTML SQL PHP
Advertisement

Insertion of a node:

The below pseudo code of INSERT-FIB-HEAP inserts a node x in the Fibonacci heap, FH.
Assume that the node x has already been allocated and x -> key is already filled:

INSERT-FIB-HEAP (FH, x)
1. x -> degree = 0
2. x -> parent = NIL
3. x -> child = NIL
4. x -> mark = FALSE
5. If FH -> min == NIL
6. create a root list for FH containing only x
7. FH -> min = x
8. Else
9. Insert x into FH's root list
10. If x -> key < FH -> min -> key
11. FH -> min = x
12. FH -> n = FH -> n + 1

Line-wise explanation of the INSERT_FIB_HEAP (FH, X) pseudo-code:

1. Initializing the degree of the node x = 0

2. Initializing the parent of the node x = NIL
3. Initializing the child of the node x = NIL
4. Marking FALSE in the mark attribute of the x
5. If-condition checks whether the Fibonacci heap (FH) is empty or not
6. If yes, the creates a new root list and adds x to it
7. Making the newly added x the minimum node
8. If the if-condition fails
9. Inserts the x in the root list
10. Checks whether the x -> key is smaller than the FH -> min
11. If yes, then it makes the x the minimum node of the FH by updating the FH -> min = x
12. In the last line, it increases the number of nodes of the FH by 1
https://www.tpointtech.com/fibonacci-heap 6/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

2. Union of two Fibonacci Heap:

Advertisement
The below pseudo-code simply concatenates the root lists of two Fibonacci heaps, FH1
and FH2 and destroys both of them during the process, determines the min node and
returns the new Fibonacci heap, FH.

UNION-FIB-HEAP (FH1, FH2)

1. FH = MAKE-FIB-HEAP ()
2. FH -> min = FH1 -> Min
3. Concatenating the root list of FH2 with the root list of FH
4. If (FH1 -> == Nil) or (H2 -> min != NIL and FH2 -> min -> key < H1 -> min -> key)
5. FH - > min = FH2 -> min
6. FH -> n = FH1 -> n + FH2 -> n
7. Return FH

Line-wise explanation of UNION-FIB-HEAP (FH1, FH2) pseudo-code:

1. Creates a new Root List FH

2. Set the min -> FH = min -> FH1; the minimum node of the FH is now the minimum node of
FH1.
3. Joins (Concatenates) the root list of FH2 with the root list of FH
4. Checks whether the min -> FH1 is null, min -> FH2 is null, and whether the min -> FH2 is
smaller than the min -> FH1 or not
5. If yes, it sets the min -> FH = min -> FH2
6. Number of nodes in FH = sum of the number of nodes in FH1 and FH2
7. Returning the FH

3. Extracting the Minimum Node:

The extraction of minimum Node is one of the most complicated operations performed
on the Fibonacci Heap. It is also where the delayed work of consolidating trees in the
root list finally occurs. The below pseudo-code extracts the minimum node of the
Fibonacci tree. For ease of use, the code assumes that when a node is removed from a
linked list, pointers in the list are updated but not pointers in the extracted node.
Additionally, it invokes the auxiliary procedure CONSOLIDATE, which we'll see in a
moment.

EXTRACT-MIN-FIB-HEAP (FH)
1. Y = FH -> Min
2. If Y != NIL
3. For each child x of Y
https://www.tpointtech.com/fibonacci-heap 7/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

4. add x to the root list of FH

5. x -> parent = NIL
Advertisement

6. Remove Z from the root list of FH

7. If Y == Y -> right
8. FH -> min = NIL
9. else
10. FH -> min = Y -> right
11. CONSOLIDATE (FH) // Explanation is given below
12. FH -> N = (FH -> N) - 1
13. Return Y

Line-wise explanation of EXTRACT-MIN-FIB-HEAP (FH) pseudo-code:

1. Saves the min pointer in Y

2. Checks if the Fibonacci heap is empty or not
3. If not, then it Runs a loop for all the children of Y
4. Adds the children of Y in the root list
5. Set the parent attributes = NIL for all the children
6. Deletes the Y node from the root list
7. If the right pointer of the Y is equal to the Y, it means that it was the only node in the
Fibonacci heap.
8. If Y was the only node setting, the FH -> min = NIL. Fibonacci heap is empty now.
9. Else part run if there is another node in the root list of FH
10. Sets the min -> FH = Y -> Right; now, min points to a different node present on the right of
the node (Note: Root list is a circular doubly linked list)
11. Calls the CONSOLIDATE (FH) function, which we have discussed below:
12. Decreases the number of nodes of FH by 1
13. Returning Y

CONSOLIDATE (FH)
1. Let A[0 ... D(FH -> N)] be a new array
2. For I = 0 to D (FH -> N)
3. A[i] = Nil
4. For each node w in the root list of H
5. X = W
6. d = X -> Degree
7. While A[d] != NIL
8. Y = A[d] // Another node with the same degree as X
9. If X -> Key > Y -> key
10. exchange X with Y
https://www.tpointtech.com/fibonacci-heap 8/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

11. LINK-FIB-HEAP (FH, Y, X) // Explanation is given below

12. A[d] = Advertisement
NIL
13. dd = d + 1
14. A[d] = X
15. H -> min = NIL
16. For I to D (FH -> N)
17. If A[I] != NIL
18. If FH -> min == NIL
19. create a root list for FH containing only A[I]
20. FH -> Min = A[I]
21. Else
22. Insert A[I] into FH's root list
23. If (A[I] -> key) < (FH -> min -> key)
24. FH -> min = A[I]

Line-wise explanation of the CONSOLIDATE (FH) pseudo-code: 2544

1. In line 1, it creates a new array of size D (FH -> N)

2. In lines 2 and 3, it fills NIL at all indexes of A.

3. - In lines 4 to 15, it executes the same process for all the nodes present in the root list.
It selects each node 'W' from the root list and stores it in 'X'. Then, it stores the degree of
X in d and runs a while loop if, at index d, it is not NIL. But initially, all the values are NIL,
so, it won't execute, and in line 14, it stores 'X' at index d. Now, the idea of while is to
check whether there is any node present in the root list of the same degree as of 'X'.

In the second iteration of the for-loop, it selects another node from the root list and
stores it in X and its degree in d. The while condition becomes true if there is a node in
the root list of the same degree as of 'X'. Suppose the condition of the while-loop is true.
Now, it stores the node of the same degree as of 'X' in Y and checks which has the larger
key. If Y has a key larger than the key of X., it swaps both of them and calls LINK-FIB-
HEAP (FH, Y, X) to delete the Y from the root list after making it a child of X, and it also
increases the degree of X by one after that.

In line 12, it removes the element stored at index d in the array and increases the value of
d by 1.

The whole idea of the code is to have exactly one node of each degree in the root list and
make other nodes a child of them without violating the condition of the Fibonacci heap.

https://www.tpointtech.com/fibonacci-heap 9/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

4. In lines 16 to 24, It runs a for loop for all the nodes stored in the array. Firstly, it checks
whether there Advertisement
is an element present in the array at index I or not. If yes, then it executes
the other peace of codes. Now, it checks whether the min of FH is NIL or not. If yes, then
it creates a root list and stores the A[I] into it and makes the FH -> min points to it. If not,
then it inserts the A[I] into the root list and compares its key value with the min -> key.
Whosoever has the smallest key, FH -> min will point to the smallest of them.

LINK-FIB-HEAP (FH, Y, X)
1. Remove Y from the root list of FH
2. Make Y a child of X and Increment X -> Degree
3. Y -> Mark = FALSE

Line-wise explanation of the LINK-FIB-HEAP (FH, Y, X) pseudo-code:

1. It removes the Y from the root list

2. Makes the Y nodes a child of X and increases the degree of X by 1

3. Marks FALSE in the Y -> mark.

4. Decreasing a Key

Decreasing a key is performed on the Fibonacci heap to decrease the key of any node
and can be performed in the O(1) amortized time. In the below pseudo code, we have
assumed that removing a from the linked list does not change any of the structural
attributes in the removed node.

1. Is the actual Fibonacci heap and

2. represents the heap after decreasing the node storing key = 45 to 15.

DECREASE-Key-FIB-HEAP (FH, X, K)
1. If K > X -> Key
2. Error "New key is greater than the current key".
3. X -> KKey = K
https://www.tpointtech.com/fibonacci-heap 10/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

4. Y = X -> P // X -> P returns its parent

5. If Y != NILAdvertisement
and X -> Key < Y -> Key
6. CUT (FH, X, Y) // Explanation is given below
7. CASCADING-CUT (FH, Y) // Explanation is given below
8. If X -> Key < FH -> min -> Key
9. H -> min = X

Line-wise explanation of DECREASE-Key-FIB-HEAP (FH, X, K) pseudo-code:

1. In lines 1 to 2, it checks whether the key entered is greater than the existing key or not.
If yes, the program terminates and will not change anything in the Fibonacci heap.

2. In line 3, Updates the key of X; now, X -> Key is equal to the k

3. In line 4, It stores the parent of X in Y

4. In line 5, The if condition will become true only if the node X does not belong to the
root list, i.e., there exists a parent of it, and the key of X must be smaller than the key of Y.

5. In line 6, it calls CUT (FH, X, Y) to remove X from the F and add it to the root list

6. In line 7, It calls CASCADING-CUT (FH, Y) to mark True in Y or to remove it from the

linked list and add it to the root list.

7. In line 8, It checks whether the X has the key smaller than the FIB -> min -> Key or not

8. In line 9, if the condition is satisfied then it makes X the min of the Fibonacci heap.

CUT (FH, X, Y)
1. Remove X from the child of Y, Decrementing Y -> Degree
2. Add X to the root list of FH
3. X -> P = NIL
X -> Mark = FALSE

CASCADING-CUT (FH, Y)
1. Z = Y -> P
2. If Z != NIL
3. If Y -> Mark == FALSE
4. Y -> Mark = TRUE
5. Else
6. CUT (FH, Y, Z)
https://www.tpointtech.com/fibonacci-heap 11/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

7. ` CASCADING CUT (FH, Z)

Advertisement

Explanation of CUT (FH, X, Y) Pseudo-code:

In the above pseudo-code, it first finds the parent of Y and stores it in Z. Then, it checks
whether the Y is in the root list or not. If not means Z is not equal to NIL, Again, it checks
whether it is marked or not, If it is marked FALSE then it changes it to TRUE and the
control returns to the FIB-DECREASE-KEY. If it is marked TRUE, then it removes Y from Z
and places Y in the root list and repeats the same process and stops when one of the
parent nodes is found unmarked.

5. Deleting a Node:

The deleting a node from an n-node Fibonacci heap can be performed in O(D(n))
amortized cost time. In the below pseudo-code, we have assumed that as of now there is
no key value of -infinity in the heap.

DELETE-FIB-HEAP (H, X)
1. DECREASE-KEY-FIB-HEAP (FH, X, -∞)
2. EXTRACT-MIN-FIB-HEAP (FH)

The DECREASE-KEY-FIB-HEAP (FH, X, -∞) decreases the key of X and makes it the
smallest possible value i.e., -infinity. The EXTRACT-MIN-HEAP function removes X from
the Fibonacci heap. It can be concluded that the amortized cost of the DELETE-FIB-
HEAP is the sum of the amortized cost of DECREASE-KEY-FIB-HEAP (O(1)) and the
amortized cost of the EXTRACT-MIN-HEAP (O(D(n)).

Next Topic Find whether an array is subset of another array

← prev next →

https://www.tpointtech.com/fibonacci-heap 12/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

Related Posts

Weight Balanced Binary Tree

In the domain of computer science and data structures, the effective organization and
retrieval of data pose several challenges. Binary trees, in their large manifestations,
assume an important role in data storage and retrieval. In this text, we will focus upon a
specific binary tree also...
 5 min read

https://www.tpointtech.com/fibonacci-heap 13/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Blending vsAdvertisement
Stacking
Introduction Stacking and Blending are two powerful and popular ensemble methods
in machine learning. They are very similar, with the difference around how to allocate
the training data. They are most noticeable for their popularity and performance in
winning Kaggle competitions. Stacking Stacking or stacked generalisation was
introduced by...

 4 min read

Program to Validate an IPv4 Address

An IPv4 address is a numerical identification provided to each device connected to a
computer network that communicates using the Internet Protocol version 4 (IPv4). It is
a 32-bit binary number split into four octets (8-bit numbers), commonly expressed in
human-readable form as a series...

 4 min read

Properties of tree in data structure

Introduction In a binary tree, which is a hierarchical data structure consisting of nodes,
each node has two children: the left child and the right child. The topmost node of the
tree is called the root node and serves as the starting point for traversing the tree....
 10 min read

K-th Largest Sum Contiguous Subarray

Introduction Within the larger class of subarray sum problems, the problem is a difficult
algorithmic task. The objective is to determine the K-th largest sum among an array's
potential contiguous subarrays. This issue has a wide range of applications in fields
where it's critical to find...
 9 min read

Decimal Equivalent of Binary Linked List

https://www.tpointtech.com/fibonacci-heap 14/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Introduction Binary numbers are an essential subject in computer science and data
representationAdvertisement
fields. Computers, which are sophisticated devices made to work with
data, depend on the binary number system, which only employs the digits 0 and 1.
However, decimal numerals, which have ten digits ranging from...
 4 min read

Delete all occurrences of a given key in a linked list

A related listing is a linear data structure where each element is a separate item. Each
element (which we will call a node) of a list includes two items - the data and a reference
to the node. The closing node has a reference to...

 4 min read

Check if the given string is K-periodic

In computational linguistics and computer science, string manipulation and pattern
recognition are basic ideas. Determining whether a given string is K-periodic or not is an
interesting challenge in this domain. If a string can be split into K equal pieces that are
all the same, then...

 7 min read

Recaman's Sequence
, named after the Colombian mathematician Bernardo Recaman Santos, is a fascinating
integer sequence that has captured the imagination of mathematicians and computer
scientists alike. It's defined by a simple yet intriguing rule, making it an excellent Java
exploration topic. Understanding Recamán's Sequence starts with the first...

 6 min read

Minimum product of k integers in an array of positive integers

Let us understand the question: We need to find out the product of k elements in an
array of size n, where k&lt;=n. Let us take an example: If the array is: [10,5,4,7,8,1,2] and the
k value is 2, We need to find the minimum possible product by multiplying...
 4 min read

https://www.tpointtech.com/fibonacci-heap 15/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Learn Important Tutorial

Advertisement

Python Java

Javascript HTML

Database PHP

C++ React

B.Tech / MCA

Data
DBMS
Structures

https://www.tpointtech.com/fibonacci-heap 16/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

Operating
DAA
System

Computer Compiler
Network Design

Computer Discrete
Organization Mathematics

Ethical Computer
Hacking Graphics

Web Software
Technology Engineering

https://www.tpointtech.com/fibonacci-heap 17/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Cyber Automata
Security
Advertisement

C
C++
Programming

Java .Net

Python Programs

Control Data
System Warehouse

Preparation

Aptitude Reasoning

https://www.tpointtech.com/fibonacci-heap 18/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

Verbal Interview
Ability Questions

Company
Questions
Advertisement

https://www.tpointtech.com/fibonacci-heap 19/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 20/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 21/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 22/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 23/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 24/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 25/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 26/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

Advertisement

Advertisement

https://www.tpointtech.com/fibonacci-heap 27/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 28/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 29/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 30/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 31/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 32/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 33/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 34/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 35/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 36/37
2/14/25, 11:38 AM Fibonacci Heap - javatpoint

Advertisement

https://www.tpointtech.com/fibonacci-heap 37/37