Open In App
Related Articles

Binary Heap

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

A Binary Heap is a complete Binary Tree which is used to store data efficiently to get the max or min element based on its structure.

A Binary Heap is either Min Heap or Max Heap. In a Min Binary Heap, the key at the root must be minimum among all keys present in Binary Heap. The same property must be recursively true for all nodes in Binary Tree. Max Binary Heap is similar to MinHeap. 

Examples of Min Heap:

            10                       10
         /      \                 /         \  
     20     100        15           30  
   /                        /    \         /    \
30                     40   50   100   40

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 ith 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.

Binary Heap Tree

Operations on Heap:

Below are some standard operations on min heap:

  • getMin(): It returns the root element of Min Heap. The time Complexity of this operation is O(1). In case of a maxheap it would be getMax().
  • extractMin(): Removes the minimum element from MinHeap. The time Complexity of this Operation is O(log N) as this operation needs to maintain the heap property (by calling heapify()) after removing the root.
  • decreaseKey(): Decreases the value of the key. The time complexity of this operation is O(log N). If the decreased key value of a node is greater than the parent of the node, then we don’t need to do anything. Otherwise, we need to traverse up to fix the violated heap property.
  • insert(): Inserting a new key takes O(log N) time. We add a new key at the end of the tree. If the new key is greater than its parent, then we don’t need to do anything. Otherwise, we need to traverse up to fix the violated heap property.
  • delete(): Deleting a key also takes O(log N) time. We replace the key to be deleted with the minimum infinite by calling decreaseKey(). After decreaseKey(), the minus infinite value must reach root, so we call extractMin() to remove the key.

Below is the implementation of basic heap operations. 

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:

Related Links:



Last Updated : 06 Feb, 2024
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads