Insertion and Deletion in Heaps

14 Jun, 2022
Deletion in Heap
Given a Binary Heap and an element present in the given Heap. The task is to delete an element from this Heap.  
The standard deletion operation on Heap is to delete the element present at the root node of the Heap. That is if it is a Max Heap, the standard deletion operation will delete the maximum element and if it is a Min heap, it will delete the minimum element.
Process of Deletion: Since deleting an element at any intermediary position in the heap can be costly, so we can simply replace the element to be deleted by the last element and delete the last element of the Heap. 
Replace the root or element to be deleted by the last element.
Delete the last element from the Heap.
Since, the last element is now placed at the position of the root node. So, it may not follow the heap property. Therefore, heapify the last node placed at the position of root.
Illustration:  
Suppose the Heap is a Max-Heap as:
      10
    /    \
   5      3
  / \
 2   4

The element to be deleted is root, i.e. 10.

Process:
The last element is 4.

Step 1: Replace the last element with root, and delete it.
      4
    /    \
   5      3
  / 
 2   

Step 2: Heapify root.
Final Heap:
      5
    /    \
   4      3
  / 
 2   
Implementation:  
C++
Java
Python3
C#
Javascript
// C++ program for implement deletion in Heaps #include <iostream> using namespace std; // To heapify a subtree rooted with node i which is// an index of arr[] and n is the size of heapvoid heapify(int arr[], int n, int i){    int largest = i; // Initialize largest as root    int l = 2 * i + 1; // left = 2*i + 1    int r = 2 * i + 2; // right = 2*i + 2     // If left child is larger than root    if (l < n && arr[l] > arr[largest])        largest = l;     // If right child is larger than largest so far    if (r < n && arr[r] > arr[largest])        largest = r;     // If largest is not root    if (largest != i) {        swap(arr[i], arr[largest]);         // Recursively heapify the affected sub-tree        heapify(arr, n, largest);    }} // Function to delete the root from Heapvoid deleteRoot(int arr[], int& n){    // Get the last element    int lastElement = arr[n - 1];     // Replace root with last element    arr[0] = lastElement;     // Decrease size of heap by 1    n = n - 1;     // heapify the root node    heapify(arr, n, 0);} /* A utility function to print array of size n */void printArray(int arr[], int n){    for (int i = 0; i < n; ++i)        cout << arr[i] << " ";    cout << "\n";} // Driver Codeint main(){    // Array representation of Max-Heap    //     10    //    /  \    //   5    3    //  / \    // 2   4    int arr[] = { 10, 5, 3, 2, 4 };     int n = sizeof(arr) / sizeof(arr[0]);     deleteRoot(arr, n);     printArray(arr, n);     return 0;}
// Java program for implement deletion in Heapspublic class deletionHeap {     // To heapify a subtree rooted with node i which is    // an index in arr[].Nn is size of heap    static void heapify(int arr[], int n, int i)    {        int largest = i; // Initialize largest as root        int l = 2 * i + 1; // left = 2*i + 1        int r = 2 * i + 2; // right = 2*i + 2         // If left child is larger than root        if (l < n && arr[l] > arr[largest])            largest = l;         // If right child is larger than largest so far        if (r < n && arr[r] > arr[largest])            largest = r;         // If largest is not root        if (largest != i) {            int swap = arr[i];            arr[i] = arr[largest];            arr[largest] = swap;             // Recursively heapify the affected sub-tree            heapify(arr, n, largest);        }    }     // Function to delete the root from Heap    static int deleteRoot(int arr[], int n)    {        // Get the last element        int lastElement = arr[n - 1];         // Replace root with first element        arr[0] = lastElement;         // Decrease size of heap by 1        n = n - 1;         // heapify the root node        heapify(arr, n, 0);         // return new size of Heap        return n;    }     /* A utility function to print array of size N */    static void printArray(int arr[], int n)    {        for (int i = 0; i < n; ++i)            System.out.print(arr[i] + " ");         System.out.println();    }     // Driver Code    public static void main(String args[])    {        // Array representation of Max-Heap        // 10        //    /  \        // 5    3        //  / \        // 2   4        int arr[] = { 10, 5, 3, 2, 4 };         int n = arr.length;         n = deleteRoot(arr, n);         printArray(arr, n);    }}
# Python 3 program for implement deletion in Heaps # To heapify a subtree rooted with node i which is# an index of arr[] and n is the size of heapdef heapify(arr, n, i):     largest = i #Initialize largest as root    l = 2 * i + 1 # left = 2*i + 1    r = 2 * i + 2 # right = 2*i + 2     #If left child is larger than root    if (l < n and arr[l] > arr[largest]):        largest = l     #If right child is larger than largest so far    if (r < n and arr[r] > arr[largest]):        largest = r     # If largest is not root    if (largest != i):        arr[i],arr[largest]=arr[largest],arr[i]         #Recursively heapify the affected sub-tree        heapify(arr, n, largest) #Function to delete the root from Heapdef deleteRoot(arr):    global n     # Get the last element    lastElement = arr[n - 1]     # Replace root with last element    arr[0] = lastElement     # Decrease size of heap by 1    n = n - 1     # heapify the root node    heapify(arr, n, 0) # A utility function to print array of size ndef printArray(arr, n):     for i in range(n):        print(arr[i],end=" ")    print() # Driver Codeif __name__ == '__main__':     # Array representation of Max-Heap    #      10    #     /  \    #    5    3    #   / \    #  2   4    arr = [ 10, 5, 3, 2, 4 ]     n = len(arr)     deleteRoot(arr)     printArray(arr, n)         # This code is contributed by Rajat Kumar.
// C# program for implement deletion in Heapsusing System; public class deletionHeap{     // To heapify a subtree rooted with node i which is    // an index in arr[].Nn is size of heap    static void heapify(int []arr, int n, int i)    {        int largest = i; // Initialize largest as root        int l = 2 * i + 1; // left = 2*i + 1        int r = 2 * i + 2; // right = 2*i + 2         // If left child is larger than root        if (l < n && arr[l] > arr[largest])            largest = l;         // If right child is larger than largest so far        if (r < n && arr[r] > arr[largest])            largest = r;         // If largest is not root        if (largest != i)        {            int swap = arr[i];            arr[i] = arr[largest];            arr[largest] = swap;             // Recursively heapify the affected sub-tree            heapify(arr, n, largest);        }    }     // Function to delete the root from Heap    static int deleteRoot(int []arr, int n)    {        // Get the last element        int lastElement = arr[n - 1];         // Replace root with first element        arr[0] = lastElement;         // Decrease size of heap by 1        n = n - 1;         // heapify the root node        heapify(arr, n, 0);         // return new size of Heap        return n;    }     /* A utility function to print array of size N */    static void printArray(int []arr, int n)    {        for (int i = 0; i < n; ++i)            Console.Write(arr[i] + " ");         Console.WriteLine();    }     // Driver Code    public static void Main()    {        // Array representation of Max-Heap        // 10        // / \        // 5 3        // / \        // 2 4        int []arr = { 10, 5, 3, 2, 4 };        int n = arr.Length;        n = deleteRoot(arr, n);        printArray(arr, n);    }} // This code is contributed by Ryuga
<script>    // Javascript program for implement deletion in Heaps         // To heapify a subtree rooted with node i which is    // an index in arr[].Nn is size of heap    function heapify(arr, n, i)    {        let largest = i; // Initialize largest as root        let l = 2 * i + 1; // left = 2*i + 1        let r = 2 * i + 2; // right = 2*i + 2           // If left child is larger than root        if (l < n && arr[l] > arr[largest])            largest = l;           // If right child is larger than largest so far        if (r < n && arr[r] > arr[largest])            largest = r;           // If largest is not root        if (largest != i)        {            let swap = arr[i];            arr[i] = arr[largest];            arr[largest] = swap;               // Recursively heapify the affected sub-tree            heapify(arr, n, largest);        }    }       // Function to delete the root from Heap    function deleteRoot(arr, n)    {        // Get the last element        let lastElement = arr[n - 1];           // Replace root with first element        arr[0] = lastElement;           // Decrease size of heap by 1        n = n - 1;           // heapify the root node        heapify(arr, n, 0);           // return new size of Heap        return n;    }       /* A utility function to print array of size N */    function printArray(arr, n)    {        for (let i = 0; i < n; ++i)            document.write(arr[i] + " ");           document.write("</br>");    }         let arr = [ 10, 5, 3, 2, 4 ];    let n = arr.length;    n = deleteRoot(arr, n);    printArray(arr, n); // This code is contributed by divyeshrabdiya07.</script>
5 4 3 2
 
Time complexity: O(logn) where n is no of elements in the heap
Auxiliary Space: O(n)
Insertion in Heaps
The insertion operation is also similar to that of the deletion process. 
Given a Binary Heap and a new element to be added to this Heap. The task is to insert the new element to the Heap maintaining the properties of Heap.  
Process of Insertion: Elements can be inserted to the heap following a similar approach as discussed above for deletion. The idea is to: 
First increase the heap size by 1, so that it can store the new element.
Insert the new element at the end of the Heap.
This newly inserted element may distort the properties of Heap for its parents. So, in order to keep the properties of Heap, heapify this newly inserted element following a bottom-up approach.
Illustration:  
Suppose the Heap is a Max-Heap as:
      10
    /    \
   5      3
  / \
 2   4

The new element to be inserted is 15.

Process:
Step 1: Insert the new element at the end.
      10
    /    \
   5      3
  / \    /
 2   4  15

Step 2: Heapify the new element following bottom-up 
        approach.
-> 15 is more than its parent 3, swap them.
       10
    /    \
   5      15
  / \    /
 2   4  3

-> 15 is again more than its parent 10, swap them.
       15
    /    \
   5      10
  / \    /
 2   4  3

Therefore, the final heap after insertion is:
       15
    /    \
   5      10
  / \    /
 2   4  3
Implementation: 
C++
Java
Python3
// C++ program to insert new element to Heap #include <iostream>using namespace std; #define MAX 1000 // Max size of Heap // Function to heapify ith node in a Heap// of size n following a Bottom-up approachvoid heapify(int arr[], int n, int i){    // Find parent    int parent = (i - 1) / 2;     if (arr[parent] > 0) {        // For Max-Heap        // If current node is greater than its parent        // Swap both of them and call heapify again        // for the parent        if (arr[i] > arr[parent]) {            swap(arr[i], arr[parent]);             // Recursively heapify the parent node            heapify(arr, n, parent);        }    }} // Function to insert a new node to the Heapvoid insertNode(int arr[], int& n, int Key){    // Increase the size of Heap by 1    n = n + 1;     // Insert the element at end of Heap    arr[n - 1] = Key;     // Heapify the new node following a    // Bottom-up approach    heapify(arr, n, n - 1);} // A utility function to print array of size nvoid printArray(int arr[], int n){    for (int i = 0; i < n; ++i)        cout << arr[i] << " ";     cout << "\n";} // Driver Codeint main(){    // Array representation of Max-Heap    // 10    //    /  \    // 5    3    //  / \    // 2   4    int arr[MAX] = { 10, 5, 3, 2, 4 };     int n = 5;     int key = 15;     insertNode(arr, n, key);     printArray(arr, n);    // Final Heap will be:    // 15    //    /   \    // 5     10    //  / \   /    // 2   4 3    return 0;}
// Java program for implementing insertion in Heapspublic class insertionHeap {     // Function to heapify ith node in a Heap    // of size n following a Bottom-up approach    static void heapify(int[] arr, int n, int i)    {        // Find parent        int parent = (i - 1) / 2;             if (arr[parent] > 0) {            // For Max-Heap            // If current node is greater than its parent            // Swap both of them and call heapify again            // for the parent            if (arr[i] > arr[parent]) {                                   // swap arr[i] and arr[parent]                int temp = arr[i];                arr[i] = arr[parent];                arr[parent] = temp;                               // Recursively heapify the parent node                heapify(arr, n, parent);            }        }    }     // Function to insert a new node to the heap.    static int insertNode(int[] arr, int n, int Key)    {        // Increase the size of Heap by 1        n = n + 1;             // Insert the element at end of Heap        arr[n - 1] = Key;             // Heapify the new node following a        // Bottom-up approach        heapify(arr, n, n - 1);                 // return new size of Heap        return n;    }     /* A utility function to print array of size n */    static void printArray(int[] arr, int n)    {        for (int i = 0; i < n; ++i)            System.out.println(arr[i] + " ");         System.out.println();    }     // Driver Code    public static void main(String args[])    {        // Array representation of Max-Heap        // 10        //    /  \        // 5    3        //  / \        // 2   4                 // maximum size of the array        int MAX = 1000;        int[] arr = new int[MAX];                 // initializing some values        arr[0] = 10;        arr[1] = 5;        arr[2] = 3;        arr[3] = 2;        arr[4] = 4;                 // Current size of the array        int n = 5;         // the element to be inserted        int Key = 15;                 // The function inserts the new element to the heap and        // returns the new size of the array        n = insertNode(arr, n, Key);         printArray(arr, n);        // Final Heap will be:        // 15        //    /   \        // 5     10        //  / \   /        // 2   4 3    }} // The code is contributed by Gautam goel
# program to insert new element to Heap # Function to heapify ith node in a Heap# of size n following a Bottom-up approach  def heapify(arr, n, i):    parent = int(((i-1)/2))    # For Max-Heap    # If current node is greater than its parent    # Swap both of them and call heapify again    # for the parent    if arr[parent] > 0:        if arr[i] > arr[parent]:            arr[i], arr[parent] = arr[parent], arr[i]            # Recursively heapify the parent node            heapify(arr, n, parent)# Function to insert a new node to the Heap  def insertNode(arr, key):    global n    # Increase the size of Heap by 1    n += 1    # Insert the element at end of Heap    arr.append(key)    # Heapify the new node following a    # Bottom-up approach    heapify(arr, n, n-1)# A utility function to print array of size n  def printArr(arr, n):    for i in range(n):        print(arr[i], end=" ")  # Driver Code# Array representation of Max-Heap'''        10       /  \      5    3     / \    2   4'''arr = [10, 5, 3, 2, 4, 1, 7]n = 7key = 15insertNode(arr, key)printArr(arr, n)# Final Heap will be:'''      15    /   \   5     10 /  \    /2    4   3 Code is written by Rajat Kumar....'''
15 5 10 2 4 3
 
Time Complexity: O(n)
Auxiliary Space: O(n)
ankthon
YashJain25
ultrainstinct
divyeshrabadiya07
dsc13103
amartyaghoshgfg
rajatkumargla19
gautamgoel962
polymatir3j
Data Structures
Heap
Data Structures
Heap
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
SDE SHEET - A Complete Guide for SDE Preparation
Introduction to Data Structures
What is Hashing | A Complete Tutorial
Introduction to Tree Data Structure
K'th Smallest/Largest Element in Unsorted Array | Set 1
Introduction to Data Structures
Huffman Coding | Greedy Algo-3
Sliding Window Maximum (Maximum of all subarrays of size k)
k largest(or smallest) elements in an array