The Wayback Machine - https://web.archive.org/web/20240927192833/https://www.geeksforgeeks.org/binary-heap/

Binary Heap

Last Updated : 06 Feb, 2024

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

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(↔[i], ↔[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(↔[i], ↔[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(↔[i], ↔[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:

GeeksforGeeks

News

Improve

Previous Article

Introduction to Heap

Applications, Advantages and Disadvantages of Heap

Similar Reads

Difference between Binary Heap, Binomial Heap and Fibonacci Heap

Binary Heap:A Binary Heap is a Binary Tree with following properties. It’s a complete binary tree i.e., all levels are completely filled except possibly the last level and the last level has all keys as left as possible. This property of Binary Heap makes them suitable to be stored in an array.A Binary Heap is either Min Heap or Max Heap. In a Min

Convert Min Heap to Max Heap

Given an array representation of min Heap, convert it to max Heap. Examples: Input: arr[] = {3, 5, 9, 6, 8, 20, 10, 12, 18, 9} 3 / \ 5 9 / \ / \ 6 8 20 10 / \ /12 18 9 Output: arr[] = {20, 18, 10, 12, 9, 9, 3, 5, 6, 8} 20 / \ 18 10 / \ / \ 12 9 9 3 / \ /5 6 8 Input: arr[] = {3, 4, 8, 11, 13}Output: arr[] = {13, 11, 8, 4, 3} Approach: To solve the p

Heap Sort for decreasing order using min heap

Given an array of elements, sort the array in decreasing order using min heap. Examples: Input : arr[] = {5, 3, 10, 1} Output : arr[] = {10, 5, 3, 1} Input : arr[] = {1, 50, 100, 25} Output : arr[] = {100, 50, 25, 1} Prerequisite: Heap sort using min heap. Algorithm : Build a min heap from the input data. At this point, the smallest item is stored

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 states that it should be A Complete Binary Tree. For

Difference between Min Heap and Max Heap

A Heap is a special Tree-based data structure in which the tree is a complete binary tree. Since a heap is a complete binary tree, a heap with N nodes has log N height. It is useful to remove the highest or lowest priority element. It is typically represented as an array. There are two types of Heaps in the data structure. Min-HeapIn a Min-Heap the

What's the relationship between "a" heap and "the" heap?

A Heap: "A Heap" refers to the heap data structure where we can store data in a specific order. Heap is a Tree-based data structure where the tree is a complete binary tree. Heap is basically of two types: Max-Heap: The key at the Root node of the tree will be the greatest among all the keys present in that heap and the same property will be follow

Complexity analysis of various operations of Binary Min Heap

A Min Heap is a Complete Binary Tree in which the children nodes have a higher value (lesser priority) than the parent nodes, i.e., any path from the root to the leaf nodes, has an ascending order of elements. In the case of a binary tree, the root is considered to be at height 0, its children nodes are considered to be at height 1, and so on. Each

Print all the leaf nodes of Binary Heap

Given an array of N elements which denotes the array representation of binary heap, the task is to find the leaf nodes of this binary heap. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7} Output: 4 5 6 7 Explanation: 1 / \ 2 3 / \ / \ 4 5 6 7 Leaf nodes of the Binary Heap are: 4 5 6 7 Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} Output: 6 7 8 9 10

Find min and max values among all maximum leaf nodes from all possible Binary Max Heap

Given a positive integer N, the task is to find the largest and smallest elements, from the maximum leaf nodes of every possible binary max-heap formed by taking the first N natural numbers as the nodes' value of the binary max-heap. Examples: Input: N = 2Output: 1 1Explanation: There is only one maximum binary heap with the nodes {1, 2}: In the ab

Check if Binary Heap is completely filled

Given an integer N which denotes the number of elements in a binary heap. Check if the binary Heap is completely filled or not. Examples: Input: 7Output: YESExplanation: At height = 0, no. of elements = 1At height = 1, no. of elements = 2At height = 2, no. of elements = 4 Last level is completely filled because at level 2 we need 22 = 4 elements to

What is Binary Heap

Binary heap is a complete binary tree where the root of any subtree has a higher (or lower based on the type of heap) value than all the nodes in its subtree. Characteristics of Binary Heap: The following are the properties of a binary heap: It is a complete binary tree, which means that all levels of the tree are completely filled, with the except

Height of a complete binary tree (or Heap) with N nodes

Consider a Binary Heap of size N. We need to find the height of it. Examples: Input : N = 6 Output : 2 () / \ () () / \ / () () () Input : N = 9 Output : 3 () / \ () () / \ / \ () () () () / \ () ()Recommended PracticeHeight of HeapTry It! Let the size of the heap be N and the height be h. If we take a few examples, we can notice that the value of

Tournament Tree (Winner Tree) and Binary Heap

Given a team of N players. How many minimum games are required to find the second-best player? We can use adversary arguments based on the tournament tree (Binary Heap). A Tournament tree is a form of min (max) heap which is a complete binary tree. Every external node represents a player and the internal node represents the winner. In a tournament

How to check if a given array represents a Binary Heap?

Given an array, how to check if the given array represents a Binary Max-Heap.Examples: Input: arr[] = {90, 15, 10, 7, 12, 2} Output: True The given array represents below tree 90 / \ 15 10 / \ / 7 12 2 The tree follows max-heap property as every node is greater than all of its descendants. Input: arr[] = {9, 15, 10, 7, 12, 11} Output: False The giv

Array Representation Of Binary Heap

A Binary Heap is a Complete Binary Tree. A binary heap is typically represented as array. The representation is done as: The root element will be at Arr[0]. Below table shows indexes 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

Given level order traversal of a Binary Tree, check if the Tree is a Min-Heap

Given the level order traversal of a Complete Binary Tree, determine whether the Binary Tree is a valid Min-Heap Examples: Input : level = [10, 15, 14, 25, 30] Output : True The tree of the given level order traversal is 10 / \ 15 14 / \ 25 30 We see that each parent has a value less than its child, and hence satisfies the min-heap property Input :

Leaf starting point in a Binary Heap data structure

Binary Heap is a complete tree (All levels are completely filled except possibly the last level and the last level has all keys as left as possible). In other words, we can say that it's an almost complete binary tree. A Binary heap is typically represented as array. If we take a closer look, we can noticed that in a Heap with number of nodes n, th

Binary Heap in Python

A Binary Heap is a complete Binary Tree that is used to store data efficiently to get the max or min element based on its structure. A Binary Heap is either a Min Heap or a Max Heap. In a Min Binary Heap, the key at the root must be minimum among all keys present in a Binary Heap. The same property must be recursively true for all nodes in the Bina

Priority Queue using Binary Heap

Priority Queue is an extension of the queue with the following properties: Every item has a priority associated with it.An element with high priority is dequeued before an element with low priority.If two elements have the same priority, they are served according to their order in the queue.A Binary Heap is a Binary Tree with the following proper

Check if a given Binary Tree is a Heap

Given a binary tree, check if it has heap property or not, Binary tree needs to fulfill the following two conditions for being a heap – It should be a complete tree (i.e. all levels except the last should be full).Every node’s value should be greater than or equal to its child node (considering max-heap).Examples: Input: Output: Given binary tree

Why is Binary Heap Preferred over BST for Priority Queue?

A typical Priority Queue requires following operations to be efficient. Get Top Priority Element (Get minimum or maximum)Insert an elementRemove top priority elementDecrease KeyA Binary Heap supports above operations with following time complexities: O(1)O(Logn)O(Logn)O(Logn) A Self Balancing Binary Search Tree like AVL Tree, Red-Black Tree, etc ca

Data Structures | Heap | Question 2

A max-heap is a heap where the value of each parent is greater than or equal to the values of its children. Which of the following is a max-heap? (GATE CS 2011) . (A) A (B) B (C) C (D) D Answer: (B) Explanation: (A) The provided tree is not a complete tree. (B) The tree is a max-heap, as the root element is greater than all of its children elements

Data Structures | Heap | Question 5

Consider a binary max-heap implemented using an array. Which among the following arrays represents a binary max-heap? (More than one option correct) (A) 25,12,16,8,10,13,14 (B) 25,12,16,13,10,8,14 (C) 25,14,16,13,10,8,12 (D) 25,14,12,13,10,8,16 Answer: (A) (C) Explanation: A tree is max-heap if data at every node in the tree is greater than or equa

Data Structures | Heap | Question 6

A min- Heap is a complete binary tree. (A) True (B) False Answer: (A) Explanation: A max-heap is a special Tree-based data structure in which the tree is a complete binary tree. A complete binary tree is a special type of binary tree where all the levels of the tree are filled completely except the lowest level nodes which are filled from as left a

Data Structures | Heap | Question 7

We have a binary heap on n elements and wish to insert n more elements (not necessarily one after another) into this heap. The total time required for this is (A) theta(logn) (B) theta(n) (C) theta(nlogn) (D) theta(n^2) (A) A (B) B (C) C (D) D Answer: (B) Explanation: We can reduce the problem to build heap for 2n elements. Time taken for build hea

Data Structures | Heap | Question 11

Given two max heaps of size n each, what is the minimum possible time complexity to make a one max-heap of size from elements of two max heaps? (A) O(n^2) (B) O(nLogLogn) (C) O(n) (D) O(nLogn) Answer: (C) Explanation: We can build a heap of 2n elements in O(n) time. Following are the steps. Create an array of size 2n and copy elements of both heaps

Number of ways to form a heap with n distinct integers

Given n, how many distinct Max Heap can be made from n distinct integers? Examples: Input : n = 3 Output : Assume the integers are 1, 2, 3. Then the 2 possible max heaps are: 3 / \ 1 2 3 / \ 2 1 Input : n = 4 Output : Assume the integers are 1, 2, 3, 4. Then the 3 possible max heaps are: 4 / \ 3 2 / 1 4 / \ 2 3 / 1 4 / \ 3 1 / 2 Since there is only

A skew heap (or self - adjusting heap) is a heap data structure implemented as a binary tree. Skew heaps are advantageous because of their ability to merge more quickly than binary heaps. In contrast with binary heaps, there are no structural constraints, so there is no guarantee that the height of the tree is logarithmic. Only two conditions must

Convert BST to Max Heap

Given a Binary Search Tree which is also a Complete Binary Tree. The problem is to convert a given BST into a Special Max Heap with the condition that all the values in the left subtree of a node should be less than all the values in the right subtree of the node. This condition is applied to all the nodes in the so-converted Max Heap. Examples: In

Top 50 Problems on Heap Data Structure asked in SDE Interviews

A Heap is a special Tree-based Data Structure in which the tree is a complete binary tree. Generally, heaps are of two types: Max-Heap and Min-Heap. To know more about this Data Structure in-depth refer to the Tutorial on Heap Data-Structure. Given below are the most frequently asked interview questions on Heaps: Easy Interview Questions on Heap D

Article Tags :

DSA
Heap

Practice Tags :

Heap