Skip to content

Advantages and Disadvantages of Heap

Binary Heap

Last Updated : 24 Mar, 2025

Try it on GfG Practice

A Binary Heap is a complete binary tree that stores data efficiently, allowing quick access to the maximum or minimum element, depending on the type of heap. It can either be a Min Heap or a Max Heap. In a Min Heap, the key at the root must be the smallest among all the keys in the heap, and this property must hold true recursively for all nodes. Similarly, a Max Heap follows the same principle, but with the largest key at the root.

Valid and Invalid examples of heaps

How is Binary Heap represented?

A Binary Heap is a Complete Binary Tree. A binary heap is typically represented as an array.

The root element will be at arr[0].
The below table shows indices of other nodes for the i^th node, i.e., arr[i]:

arr[(i-1)/2]	Returns the parent node
arr[(2*i)+1]	Returns the left child node
arr[(2*i)+2]	Returns the right child node

The traversal method use to achieve Array representation is Level Order Traversal. Please refer to Array Representation Of Binary Heap for details.

Representation-of-a-Binary-Heap — Representation of Binary Heap

Operations on Heap

Refer Introduction to Min-Heap – Data Structure and Algorithm Tutorials for more

C++

// A C++ program to demonstrate common Binary Heap Operations #include<iostream> #include<climits> using namespace std;  // Prototype of a utility function to swap two integers void swap(int *x, int *y);  // A class for Min Heap class MinHeap {     int *harr; // pointer to array of elements in heap     int capacity; // maximum possible size of min heap     int heap_size; // Current number of elements in min heap public:     // Constructor     MinHeap(int capacity);      // to heapify a subtree with the root at given index     void MinHeapify(int i);      int parent(int i) { return (i-1)/2; }      // to get index of left child of node at index i     int left(int i) { return (2*i + 1); }      // to get index of right child of node at index i     int right(int i) { return (2*i + 2); }      // to extract the root which is the minimum element     int extractMin();      // Decreases key value of key at index i to new_val     void decreaseKey(int i, int new_val);      // Returns the minimum key (key at root) from min heap     int getMin() { return harr[0]; }      // Deletes a key stored at index i     void deleteKey(int i);      // Inserts a new key 'k'     void insertKey(int k); };  // Constructor: Builds a heap from a given array a[] of given size MinHeap::MinHeap(int cap) {     heap_size = 0;     capacity = cap;     harr = new int[cap]; }  // Inserts a new key 'k' void MinHeap::insertKey(int k) {     if (heap_size == capacity)     {         cout << "\nOverflow: Could not insertKey\n";         return;     }      // First insert the new key at the end     heap_size++;     int i = heap_size - 1;     harr[i] = k;      // Fix the min heap property if it is violated     while (i != 0 && harr[parent(i)] > harr[i])     {        swap(&harr[i], &harr[parent(i)]);        i = parent(i);     } }  // Decreases value of key at index 'i' to new_val.  It is assumed that // new_val is smaller than harr[i]. void MinHeap::decreaseKey(int i, int new_val) {     harr[i] = new_val;     while (i != 0 && harr[parent(i)] > harr[i])     {        swap(&harr[i], &harr[parent(i)]);        i = parent(i);     } }  // Method to remove minimum element (or root) from min heap int MinHeap::extractMin() {     if (heap_size <= 0)         return INT_MAX;     if (heap_size == 1)     {         heap_size--;         return harr[0];     }      // Store the minimum value, and remove it from heap     int root = harr[0];     harr[0] = harr[heap_size-1];     heap_size--;     MinHeapify(0);      return root; }   // This function deletes key at index i. It first reduced value to minus // infinite, then calls extractMin() void MinHeap::deleteKey(int i) {     decreaseKey(i, INT_MIN);     extractMin(); }  // A recursive method to heapify a subtree with the root at given index // This method assumes that the subtrees are already heapified void MinHeap::MinHeapify(int i) {     int l = left(i);     int r = right(i);     int smallest = i;     if (l < heap_size && harr[l] < harr[i])         smallest = l;     if (r < heap_size && harr[r] < harr[smallest])         smallest = r;     if (smallest != i)     {         swap(&harr[i], &harr[smallest]);         MinHeapify(smallest);     } }  // A utility function to swap two elements void swap(int *x, int *y) {     int temp = *x;     *x = *y;     *y = temp; }  // Driver program to test above functions int main() {     MinHeap h(11);     h.insertKey(3);     h.insertKey(2);     h.deleteKey(1);     h.insertKey(15);     h.insertKey(5);     h.insertKey(4);     h.insertKey(45);     cout << h.extractMin() << " ";     cout << h.getMin() << " ";     h.decreaseKey(2, 1);     cout << h.getMin();     return 0; }

Java

// Java program for the above approach import java.util.*;  // A class for Min Heap  class MinHeap {          // To store array of elements in heap     private int[] heapArray;          // max size of the heap     private int capacity;          // Current number of elements in the heap     private int current_heap_size;      // Constructor      public MinHeap(int n) {         capacity = n;         heapArray = new int[capacity];         current_heap_size = 0;     }          // Swapping using reference      private void swap(int[] arr, int a, int b) {         int temp = arr[a];         arr[a] = arr[b];         arr[b] = temp;     }               // Get the Parent index for the given index     private int parent(int key) {         return (key - 1) / 2;     }          // Get the Left Child index for the given index     private int left(int key) {         return 2 * key + 1;     }          // Get the Right Child index for the given index     private int right(int key) {         return 2 * key + 2;     }               // Inserts a new key     public boolean insertKey(int key) {         if (current_heap_size == capacity) {                          // heap is full             return false;         }              // First insert the new key at the end          int i = current_heap_size;         heapArray[i] = key;         current_heap_size++;                  // Fix the min heap property if it is violated          while (i != 0 && heapArray[i] < heapArray[parent(i)]) {             swap(heapArray, i, parent(i));             i = parent(i);         }         return true;     }          // Decreases value of given key to new_val.      // It is assumed that new_val is smaller      // than heapArray[key].      public void decreaseKey(int key, int new_val) {         heapArray[key] = new_val;          while (key != 0 && heapArray[key] < heapArray[parent(key)]) {             swap(heapArray, key, parent(key));             key = parent(key);         }     }          // Returns the minimum key (key at     // root) from min heap      public int getMin() {         return heapArray[0];     }               // Method to remove minimum element      // (or root) from min heap      public int extractMin() {         if (current_heap_size <= 0) {             return Integer.MAX_VALUE;         }          if (current_heap_size == 1) {             current_heap_size--;             return heapArray[0];         }                  // Store the minimum value,          // and remove it from heap          int root = heapArray[0];          heapArray[0] = heapArray[current_heap_size - 1];         current_heap_size--;         MinHeapify(0);          return root;     }              // This function deletes key at the      // given index. It first reduced value      // to minus infinite, then calls extractMin()     public void deleteKey(int key) {         decreaseKey(key, Integer.MIN_VALUE);         extractMin();     }          // A recursive method to heapify a subtree      // with the root at given index      // This method assumes that the subtrees     // are already heapified     private void MinHeapify(int key) {         int l = left(key);         int r = right(key);          int smallest = key;         if (l < current_heap_size && heapArray[l] < heapArray[smallest]) {             smallest = l;         }         if (r < current_heap_size && heapArray[r] < heapArray[smallest]) {             smallest = r;         }          if (smallest != key) {             swap(heapArray, key, smallest);             MinHeapify(smallest);         }     }          // Increases value of given key to new_val.     // It is assumed that new_val is greater      // than heapArray[key].      // Heapify from the given key     public void increaseKey(int key, int new_val) {         heapArray[key] = new_val;         MinHeapify(key);     }          // Changes value on a key     public void changeValueOnAKey(int key, int new_val) {         if (heapArray[key] == new_val) {             return;         }         if (heapArray[key] < new_val) {             increaseKey(key, new_val);         } else {             decreaseKey(key, new_val);         }     } }  // Driver Code class MinHeapTest {     public static void main(String[] args) {         MinHeap h = new MinHeap(11);         h.insertKey(3);         h.insertKey(2);         h.deleteKey(1);         h.insertKey(15);         h.insertKey(5);         h.insertKey(4);         h.insertKey(45);         System.out.print(h.extractMin() + " ");         System.out.print(h.getMin() + " ");                  h.decreaseKey(2, 1);         System.out.print(h.getMin());     } }  // This code is contributed by rishabmalhdijo

Python

# A Python program to demonstrate common binary heap operations  # Import the heap functions from python library from heapq import heappush, heappop, heapify   # heappop - pop and return the smallest element from heap # heappush - push the value item onto the heap, maintaining #             heap invarient # heapify - transform list into heap, in place, in linear time  # A class for Min Heap class MinHeap:          # Constructor to initialize a heap     def __init__(self):         self.heap = []       def parent(self, i):         return (i-1)/2          # Inserts a new key 'k'     def insertKey(self, k):         heappush(self.heap, k)                 # Decrease value of key at index 'i' to new_val     # It is assumed that new_val is smaller than heap[i]     def decreaseKey(self, i, new_val):         self.heap[i]  = new_val          while(i != 0 and self.heap[self.parent(i)] > self.heap[i]):             # Swap heap[i] with heap[parent(i)]             self.heap[i] , self.heap[self.parent(i)] = (             self.heap[self.parent(i)], self.heap[i])                  # Method to remove minimum element from min heap     def extractMin(self):         return heappop(self.heap)      # This function deletes key at index i. It first reduces     # value to minus infinite and then calls extractMin()     def deleteKey(self, i):         self.decreaseKey(i, float("-inf"))         self.extractMin()      # Get the minimum element from the heap     def getMin(self):         return self.heap[0]  # Driver pgoratm to test above function heapObj = MinHeap() heapObj.insertKey(3) heapObj.insertKey(2) heapObj.deleteKey(1) heapObj.insertKey(15) heapObj.insertKey(5) heapObj.insertKey(4) heapObj.insertKey(45)  print heapObj.extractMin(), print heapObj.getMin(), heapObj.decreaseKey(2, 1) print heapObj.getMin()  # This code is contributed by Nikhil Kumar Singh(nickzuck_007)

C#

// C# program to demonstrate common  // Binary Heap Operations - Min Heap using System;  // A class for Min Heap  class MinHeap{      // To store array of elements in heap public int[] heapArray{ get; set; }  // max size of the heap public int capacity{ get; set; }  // Current number of elements in the heap public int current_heap_size{ get; set; }  // Constructor  public MinHeap(int n) {     capacity = n;     heapArray = new int[capacity];     current_heap_size = 0; }  // Swapping using reference  public static void Swap<T>(ref T lhs, ref T rhs) {     T temp = lhs;     lhs = rhs;     rhs = temp; }  // Get the Parent index for the given index public int Parent(int key)  {     return (key - 1) / 2; }  // Get the Left Child index for the given index public int Left(int key) {     return 2 * key + 1; }  // Get the Right Child index for the given index public int Right(int key) {     return 2 * key + 2; }  // Inserts a new key public bool insertKey(int key) {     if (current_heap_size == capacity)     {                  // heap is full         return false;     }      // First insert the new key at the end      int i = current_heap_size;     heapArray[i] = key;     current_heap_size++;      // Fix the min heap property if it is violated      while (i != 0 && heapArray[i] <                       heapArray[Parent(i)])     {         Swap(ref heapArray[i],              ref heapArray[Parent(i)]);         i = Parent(i);     }     return true; }  // Decreases value of given key to new_val.  // It is assumed that new_val is smaller  // than heapArray[key].  public void decreaseKey(int key, int new_val) {     heapArray[key] = new_val;      while (key != 0 && heapArray[key] <                         heapArray[Parent(key)])     {         Swap(ref heapArray[key],               ref heapArray[Parent(key)]);         key = Parent(key);     } }  // Returns the minimum key (key at // root) from min heap  public int getMin() {     return heapArray[0]; }  // Method to remove minimum element  // (or root) from min heap  public int extractMin() {     if (current_heap_size <= 0)     {         return int.MaxValue;     }      if (current_heap_size == 1)     {         current_heap_size--;         return heapArray[0];     }      // Store the minimum value,      // and remove it from heap      int root = heapArray[0];      heapArray[0] = heapArray[current_heap_size - 1];     current_heap_size--;     MinHeapify(0);      return root; }  // This function deletes key at the  // given index. It first reduced value  // to minus infinite, then calls extractMin() public void deleteKey(int key) {     decreaseKey(key, int.MinValue);     extractMin(); }  // A recursive method to heapify a subtree  // with the root at given index  // This method assumes that the subtrees // are already heapified public void MinHeapify(int key) {     int l = Left(key);     int r = Right(key);      int smallest = key;     if (l < current_heap_size &&          heapArray[l] < heapArray[smallest])     {         smallest = l;     }     if (r < current_heap_size &&          heapArray[r] < heapArray[smallest])     {         smallest = r;     }          if (smallest != key)     {         Swap(ref heapArray[key],               ref heapArray[smallest]);         MinHeapify(smallest);     } }  // Increases value of given key to new_val. // It is assumed that new_val is greater  // than heapArray[key].  // Heapify from the given key public void increaseKey(int key, int new_val) {     heapArray[key] = new_val;     MinHeapify(key); }  // Changes value on a key public void changeValueOnAKey(int key, int new_val) {     if (heapArray[key] == new_val)     {         return;     }     if (heapArray[key] < new_val)     {         increaseKey(key, new_val);     } else     {         decreaseKey(key, new_val);     } } }  static class MinHeapTest{      // Driver code public static void Main(string[] args) {     MinHeap h = new MinHeap(11);     h.insertKey(3);     h.insertKey(2);     h.deleteKey(1);     h.insertKey(15);     h.insertKey(5);     h.insertKey(4);     h.insertKey(45);          Console.Write(h.extractMin() + " ");     Console.Write(h.getMin() + " ");          h.decreaseKey(2, 1);     Console.Write(h.getMin()); } }  // This code is contributed by  // Dinesh Clinton Albert(dineshclinton)

JavaScript

// A class for Min Heap class MinHeap {     // Constructor: Builds a heap from a given array a[] of given size     constructor()     {         this.arr = [];     }      left(i) {         return 2*i + 1;     }      right(i) {         return 2*i + 2;     }      parent(i){         return Math.floor((i - 1)/2)     }          getMin()     {         return this.arr[0]     }          insert(k)     {         let arr = this.arr;         arr.push(k);              // Fix the min heap property if it is violated         let i = arr.length - 1;         while (i > 0 && arr[this.parent(i)] > arr[i])         {             let p = this.parent(i);             [arr[i], arr[p]] = [arr[p], arr[i]];             i = p;         }     }      // Decreases value of key at index 'i' to new_val.      // It is assumed that new_val is smaller than arr[i].     decreaseKey(i, new_val)     {         let arr = this.arr;         arr[i] = new_val;                  while (i !== 0 && arr[this.parent(i)] > arr[i])         {            let p = this.parent(i);            [arr[i], arr[p]] = [arr[p], arr[i]];            i = p;         }     }      // Method to remove minimum element (or root) from min heap     extractMin()     {         let arr = this.arr;         if (arr.length == 1) {             return arr.pop();         }                  // Store the minimum value, and remove it from heap         let res = arr[0];         arr[0] = arr[arr.length-1];         arr.pop();         this.MinHeapify(0);         return res;     }       // This function deletes key at index i. It first reduced value to minus     // infinite, then calls extractMin()     deleteKey(i)     {         this.decreaseKey(i, this.arr[0] - 1);         this.extractMin();     }      // A recursive method to heapify a subtree with the root at given index     // This method assumes that the subtrees are already heapified     MinHeapify(i)     {         let arr = this.arr;         let n = arr.length;         if (n === 1) {             return;         }         let l = this.left(i);         let r = this.right(i);         let smallest = i;         if (l < n && arr[l] < arr[i])             smallest = l;         if (r < n && arr[r] < arr[smallest])             smallest = r;         if (smallest !== i)         {             [arr[i], arr[smallest]] = [arr[smallest], arr[i]]             this.MinHeapify(smallest);         }     } }  let h = new MinHeap();     h.insert(3);      h.insert(2);     h.deleteKey(1);     h.insert(15);     h.insert(5);     h.insert(4);     h.insert(45);          console.log(h.extractMin() + " ");     console.log(h.getMin() + " ");          h.decreaseKey(2, 1);      console.log(h.extractMin());

Output

2 4 1

Applications of Heaps

Heap Sort: Heap Sort uses Binary Heap to sort an array in O(nLogn) time.
Priority Queue: Priority queues can be efficiently implemented using Binary Heap because it supports insert(), delete() and extractmax(), decreaseKey() operations in O(log N) time. Binomial Heap and Fibonacci Heap are variations of Binary Heap. These variations perform union also efficiently.
Graph Algorithms: The priority queues are especially used in Graph Algorithms like Dijkstra's Shortest Path and Prim's Minimum Spanning Tree.
Many problems can be efficiently solved using Heaps.
See following for example. a) K'th Largest Element in an array. b) Sort an almost sorted array/ c) Merge K Sorted Arrays.

Related Links:

Advantages and Disadvantages of Heap

K

kartik

Improve

Article Tags :

Heap
DSA

Practice Tags :

Heap

Similar Reads

Heap Data Structure

A Heap is a complete binary tree data structure that satisfies the heap property: for every node, the value of its children is greater than or equal to its own value. Heaps are usually used to implement priority queues, where the smallest (or largest) element is always at the root of the tree.Basics

Introduction to Heap - Data Structure and Algorithm Tutorials

A Heap is a special tree-based data structure with the following properties:It is a complete binary tree (all levels are fully filled except possibly the last, which is filled from left to right).It satisfies either the max-heap property (every parent node is greater than or equal to its children) o

A Binary Heap is a complete binary tree that stores data efficiently, allowing quick access to the maximum or minimum element, depending on the type of heap. It can either be a Min Heap or a Max Heap. In a Min Heap, the key at the root must be the smallest among all the keys in the heap, and this pr

Advantages and Disadvantages of Heap

Advantages of Heap Data StructureTime Efficient: Heaps have an average time complexity of O(log n) for inserting and deleting elements, making them efficient for large datasets. We can convert any array to a heap in O(n) time. The most important thing is, we can get the min or max in O(1) timeSpace

Time Complexity of building a heap

Consider the following algorithm for building a Heap of an input array A. A quick look over the above implementation suggests that the running time is O(n * lg(n)) since each call to Heapify costs O(lg(n)) and Build-Heap makes O(n) such calls. This upper bound, though correct, is not asymptotically

Applications of Heap Data Structure

Heap Data Structure is generally taught with Heapsort. Heapsort algorithm has limited uses because Quicksort is better in practice. Nevertheless, the Heap data structure itself is enormously used. Priority Queues: Heaps are commonly used to implement priority queues, where elements with higher prior

Comparison between Heap and Tree

What is Heap? A Heap is a special Tree-based data structure in which the tree is a complete binary tree. Types of Heap Data Structure: Generally, Heaps can be of two types: Max-Heap: In a Max-Heap the key present at the root node must be greatest among the keys present at all of its children. The sa

When building a Heap, is the structure of Heap unique?

What is Heap? A heap is a tree based data structure where the tree is a complete binary tree that maintains the property that either the children of a node are less than itself (max heap) or the children are greater than the node (min heap). Properties of Heap: Structural Property: This property sta