GeeksforGeeks App
Open App
Browser
Continue

# Fibonacci Heap – Insertion and Union

Fibonacci Heap is a collection of trees with min-heap or max-heap property. In Fibonacci Heap, trees can have any shape even all trees can be single nodes (This is unlike Binomial Heap where every tree has to be a Binomial Tree). In this article, we will discuss Insertion and Union operation on Fibonacci Heap.

Prerequisites: Fibonacci Heap (Introduction)

Insertion: To insert a node in a Fibonacci heap H, the following algorithm is followed:

1. Create a new node ‘x’.
2. Check whether heap H is empty or not.
3. If H is empty then:
• Make x as the only node in the root list.
• Set H(min) pointer to x.
4. Else:
• Insert x into root list and update H(min).

Example:

Union: Union of two Fibonacci heaps H1 and H2 can be accomplished as follows:

1. Join root lists of Fibonacci heaps H1 and H2 and make a single Fibonacci heap H.
2. If H1(min) < H2(min) then:
• H(min) = H1(min).
3. Else:
• H(min) = H2(min).

Example:

Following is a program to demonstrate building and inserting in a Fibonacci heap:

## C++

 `// C++ program to demonstrate building``// and inserting in a Fibonacci heap``#include ``#include ``#include ``using` `namespace` `std;` `struct` `node {``    ``node* parent;``    ``node* child;``    ``node* left;``    ``node* right;``    ``int` `key;``};` `// Creating min pointer as "mini"``struct` `node* mini = NULL;` `// Declare an integer for number of nodes in the heap``int` `no_of_nodes = 0;` `// Function to insert a node in heap``void` `insertion(``int` `val)``{``    ``struct` `node* new_node = (``struct` `node*)``malloc``(``sizeof``(``struct` `node));``    ``new_node->key = val;``    ``new_node->parent = NULL;``    ``new_node->child = NULL;``    ``new_node->left = new_node;``    ``new_node->right = new_node;``    ``if` `(mini != NULL) {``        ``(mini->left)->right = new_node;``        ``new_node->right = mini;``        ``new_node->left = mini->left;``        ``mini->left = new_node;``        ``if` `(new_node->key < mini->key)``            ``mini = new_node;``    ``}``    ``else` `{``        ``mini = new_node;``    ``}``}` `// Function to display the heap``void` `display(``struct` `node* mini)``{``    ``node* ptr = mini;``    ``if` `(ptr == NULL)``        ``cout << ``"The Heap is Empty"` `<< endl;` `    ``else` `{``        ``cout << ``"The root nodes of Heap are: "` `<< endl;``        ``do` `{``            ``cout << ptr->key;``            ``ptr = ptr->right;``            ``if` `(ptr != mini) {``                ``cout << ``"-->"``;``            ``}``        ``} ``while` `(ptr != mini && ptr->right != NULL);``        ``cout << endl``             ``<< ``"The heap has "` `<< no_of_nodes << ``" nodes"` `<< endl;``    ``}``}``// Function to find min node in the heap``void` `find_min(``struct` `node* mini)``{``    ``cout << ``"min of heap is: "` `<< mini->key << endl;``}`  `// Driver code``int` `main()``{` `    ``no_of_nodes = 7;``    ``insertion(4);``    ``insertion(3);``    ``insertion(7);``    ``insertion(5);``    ``insertion(2);``    ``insertion(1);``    ``insertion(10);` `    ``display(mini);` `    ``find_min(mini);` `    ``return` `0;``}`

## Python3

 `# Python program to demonstrate building``# and inserting in a Fibonacci heap`  `class` `node:``    ``def` `__init__(``self``):``        ``self``.parent ``=` `None`  `# Assign data``        ``self``.child ``=` `None`  `# Initialize next as null``        ``self``.left ``=` `None``        ``self``.right ``=` `None``        ``self``.key ``=` `-``1`  `# Creating min pointer as "mini"``mini ``=` `node()` `# Declare an integer for number of nodes in the heap``no_of_nodes ``=` `0` `# Function to insert a node in heap`  `def` `insertion(val):``    ``new_node ``=` `node()``    ``new_node.key ``=` `val``    ``new_node.parent ``=` `None``    ``new_node.child ``=` `None``    ``new_node.left ``=` `new_node``    ``new_node.right ``=` `new_node` `    ``global` `mini``    ``if` `mini.key !``=` `-``1``:``        ``(mini.left).right ``=` `new_node``        ``new_node.right ``=` `mini``        ``new_node.left ``=` `mini.left``        ``mini.left ``=` `new_node``        ``if` `(new_node.key < mini.key):``            ``mini ``=` `new_node``    ``else``:``        ``mini ``=` `new_node` `# Function to display the heap`  `def` `display(mini):``    ``ptr ``=` `mini``    ``if` `(ptr ``=``=` `None``):``        ``print``(``"The Heap is Empty"``)``    ``else``:` `        ``print``(``"The root nodes of Heap are: "``)``        ``print``(ptr.key, end``=``"")``        ``ptr ``=` `ptr.right``        ``if``(ptr !``=` `mini):``            ``print``(``"-->"``, end``=``"")` `        ``while` `ptr !``=` `mini ``and` `ptr.right !``=` `None``:``            ``print``(ptr.key, end``=``"")``            ``ptr ``=` `ptr.right``            ``if` `ptr !``=` `mini:``                ``print``(``"-->"``, end``=``"")``        ``print``()``        ``print``(f``"The heap has {no_of_nodes} nodes"``)` `# Function to find min node in the heap`  `def` `find_min(mini):``    ``print``(f``"min of heap is: {mini.key}"``)`  `# Driver code``no_of_nodes ``=` `7``insertion(``4``)``insertion(``3``)``insertion(``7``)``insertion(``5``)``insertion(``2``)``insertion(``1``)``insertion(``10``)` `display(mini)` `find_min(mini)` `# The code is contributed by Gautam goel (gautamgoel962)`

## C#

 `// C# program to demonstrate building``// and inserting in a Fibonacci heap``using` `System;` `class` `FibonacciHeap``{``class` `Node``{``public` `Node parent;``public` `Node child;``public` `Node left;``public` `Node right;``public` `int` `key;``};``  ``// Creating min pointer as "mini"``static` `Node mini = ``null``;` `// Declare an integer for number of nodes in the heap``static` `int` `no_of_nodes = 0;` `// Function to insert a node in heap``static` `void` `Insertion(``int` `val)``{``    ``Node new_node = ``new` `Node();``    ``new_node.key = val;``    ``new_node.parent = ``null``;``    ``new_node.child = ``null``;``    ``new_node.left = new_node;``    ``new_node.right = new_node;` `    ``if` `(mini != ``null``)``    ``{``        ``(mini.left).right = new_node;``        ``new_node.right = mini;``        ``new_node.left = mini.left;``        ``mini.left = new_node;` `        ``if` `(new_node.key < mini.key)``            ``mini = new_node;``    ``}``    ``else``    ``{``        ``mini = new_node;``    ``}``}` `// Function to display the heap``static` `void` `Display(Node mini)``{``    ``Node ptr = mini;``    ``if` `(ptr == ``null``)``        ``Console.WriteLine(``"The Heap is Empty"``);` `    ``else``    ``{``        ``Console.WriteLine(``"The root nodes of Heap are: "``);``        ``do``        ``{``            ``Console.Write(ptr.key);``            ``ptr = ptr.right;``            ``if` `(ptr != mini)``            ``{``                ``Console.Write(``"-->"``);``            ``}``        ``} ``while` `(ptr != mini && ptr.right != ``null``);``        ``Console.WriteLine();``        ``Console.WriteLine(``"The heap has "` `+ no_of_nodes + ``" nodes"``);``    ``}``}` `// Function to find min node in the heap``static` `void` `FindMin(Node mini)``{``    ``Console.WriteLine(``"min of heap is: "` `+ mini.key);``}`  `// Driver code``static` `void` `Main()``{``    ``no_of_nodes = 7;``    ``Insertion(4);``    ``Insertion(3);``    ``Insertion(7);``    ``Insertion(5);``    ``Insertion(2);``    ``Insertion(1);``    ``Insertion(10);` `    ``Display(mini);` `    ``FindMin(mini);``}``}`

## Javascript

 `// JavaScript program to demonstrate building``// and inserting in a Fibonacci heap` `class Node {``constructor() {``this``.parent = ``null``; ``// Assign data``this``.child = ``null``; ``// Initialize next as null``this``.left = ``null``;``this``.right = ``null``;``this``.key = -1;``}``}` `// Creating min pointer as "mini"``let mini = ``new` `Node();` `// Declare an integer for number of nodes in the heap``let no_of_nodes = 0;` `// Function to insert a node in heap``function` `insertion(val) {``let new_node = ``new` `Node();``new_node.key = val;``new_node.parent = ``null``;``new_node.child = ``null``;``new_node.left = new_node;``new_node.right = new_node;` `if` `(mini.key != -1) {``mini.left.right = new_node;``new_node.right = mini;``new_node.left = mini.left;``mini.left = new_node;``if` `(new_node.key < mini.key) {``mini = new_node;``}``} ``else` `{``mini = new_node;``}``}` `// Function to display the heap``function` `display(mini) {``let ptr = mini;``if` `(ptr === ``null``) {``document.write(``"The Heap is Empty"``);``} ``else` `{``document.write(``"The root nodes of Heap are: "``);``document.write(ptr.key.toString());``ptr = ptr.right;``if` `(ptr !== mini) {``document.write(``"-->"``);``}`  `while` `(ptr !== mini && ptr.right !== ``null``) {``  ``document.write(ptr.key.toString());``  ``ptr = ptr.right;``  ``if` `(ptr !== mini) {``    ``document.write(``"-->"``);``  ``}``}``document.write(``"
"``);``document.write(`The heap has \${no_of_nodes} nodes
`);``}``}` `// Function to find min node in the heap``function` `find_min(mini) {``document.write(`min of heap is: \${mini.key}
`);``}` `// Driver code``no_of_nodes = 7;``insertion(4);``insertion(3);``insertion(7);``insertion(5);``insertion(2);``insertion(1);``insertion(10);` `display(mini);` `find_min(mini);`

## Java

 `// Java program to demonstrate building and inserting in a``// Fibonacci heap` `import` `java.io.*;` `class` `Node {``    ``Node parent;``    ``Node child;``    ``Node left;``    ``Node right;``    ``int` `key;``}` `class` `GFG {` `    ``// Creating min pointer as "mini"``    ``static` `Node mini = ``null``;` `    ``// Declare an integer for number of nodes in the heap``    ``static` `int` `no_of_nodes = ``0``;` `    ``// Function to insert a node in heap``    ``static` `void` `Insertion(``int` `val)``    ``{``        ``Node new_node = ``new` `Node();``        ``new_node.key = val;``        ``new_node.parent = ``null``;``        ``new_node.child = ``null``;``        ``new_node.left = new_node;``        ``new_node.right = new_node;` `        ``if` `(mini != ``null``) {``            ``(mini.left).right = new_node;``            ``new_node.right = mini;``            ``new_node.left = mini.left;``            ``mini.left = new_node;` `            ``if` `(new_node.key < mini.key)``                ``mini = new_node;``        ``}``        ``else` `{``            ``mini = new_node;``        ``}``    ``}` `    ``// Function to display the heap``    ``static` `void` `Display(Node mini)``    ``{``        ``Node ptr = mini;``        ``if` `(ptr == ``null``)``            ``System.out.println(``"The Heap is Empty"``);` `        ``else` `{``            ``System.out.println(``                ``"The root nodes of Heap are: "``);``            ``do` `{``                ``System.out.print(ptr.key);``                ``ptr = ptr.right;``                ``if` `(ptr != mini) {``                    ``System.out.print(``"-->"``);``                ``}``            ``} ``while` `(ptr != mini && ptr.right != ``null``);``            ``System.out.println();``            ``System.out.println(``"The heap has "` `+ no_of_nodes``                               ``+ ``" nodes"``);``        ``}``    ``}` `    ``// Function to find min node in the heap``    ``static` `void` `FindMin(Node mini)``    ``{``        ``System.out.println(``"min of heap is: "` `+ mini.key);``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``no_of_nodes = ``7``;``        ``Insertion(``4``);``        ``Insertion(``3``);``        ``Insertion(``7``);``        ``Insertion(``5``);``        ``Insertion(``2``);``        ``Insertion(``1``);``        ``Insertion(``10``);` `        ``Display(mini);` `        ``FindMin(mini);``    ``}``}` `// This code is contributed by karthik.`

Output

```The root nodes of Heap are:
1-->2-->3-->4-->7-->5-->10
The heap has 7 nodes
min of heap is: 1```

My Personal Notes arrow_drop_up