Heap Sort for decreasing order using min heap

20 Jun, 2022
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 : 1. Build a min heap from the input data. 2. At this point, the smallest item is stored at the root of the heap. Replace it with the last item of the heap followed by reducing the size of heap by 1. Finally, heapify the root of tree. 3. Repeat above steps while size of heap is greater than 1.Note :Heap Sort using min heap sorts in descending order where as max heap sorts in ascending order 
C++
Java
Python3
C#
Javascript
// C++ program for implementation of Heap Sort#include <bits/stdc++.h>using namespace std; // To heapify a subtree rooted with node i which is// an index in arr[]. n is size of heapvoid heapify(int arr[], int n, int i){    int smallest = i; // Initialize smallest as root    int l = 2 * i + 1; // left = 2*i + 1    int r = 2 * i + 2; // right = 2*i + 2     // If left child is smaller than root    if (l < n && arr[l] < arr[smallest])        smallest = l;     // If right child is smaller than smallest so far    if (r < n && arr[r] < arr[smallest])        smallest = r;     // If smallest is not root    if (smallest != i) {        swap(arr[i], arr[smallest]);         // Recursively heapify the affected sub-tree        heapify(arr, n, smallest);    }} // main function to do heap sortvoid heapSort(int arr[], int n){    // Build heap (rearrange array)    for (int i = n / 2 - 1; i >= 0; i--)        heapify(arr, n, i);     // One by one extract an element from heap    for (int i = n - 1; i >= 0; i--) {        // Move current root to end        swap(arr[0], arr[i]);         // call min heapify on the reduced heap        heapify(arr, i, 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 programint main(){    int arr[] = { 4, 6, 3, 2, 9 };    int n = sizeof(arr) / sizeof(arr[0]);     heapSort(arr, n);     cout << "Sorted array is \n";    printArray(arr, n);}
// Java program for implementation of Heap Sort import java.io.*; class GFG {         // To heapify a subtree rooted with node i which is    // an index in arr[]. n is size of heap    static void heapify(int arr[], int n, int i)    {        int smallest = i; // Initialize smallest as root        int l = 2 * i + 1; // left = 2*i + 1        int r = 2 * i + 2; // right = 2*i + 2         // If left child is smaller than root        if (l < n && arr[l] < arr[smallest])            smallest = l;         // If right child is smaller than smallest so far        if (r < n && arr[r] < arr[smallest])            smallest = r;         // If smallest is not root        if (smallest != i) {            int temp = arr[i];            arr[i] = arr[smallest];            arr[smallest] = temp;             // Recursively heapify the affected sub-tree            heapify(arr, n, smallest);        }    }     // main function to do heap sort    static void heapSort(int arr[], int n)    {        // Build heap (rearrange array)        for (int i = n / 2 - 1; i >= 0; i--)            heapify(arr, n, i);         // One by one extract an element from heap        for (int i = n - 1; i >= 0; i--) {                         // Move current root to end            int temp = arr[0];            arr[0] = arr[i];            arr[i] = temp;             // call min heapify on the reduced heap            heapify(arr, i, 0);        }    }     /* 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 program    public static void main(String[] args)    {        int arr[] = { 4, 6, 3, 2, 9 };        int n = arr.length;         heapSort(arr, n);         System.out.println("Sorted array is ");        printArray(arr, n);    }} // This code is contributed by vt_m.
# Python3 program for implementation# of Heap Sort # To heapify a subtree rooted with# node i which is an index in arr[].# n is size of heapdef heapify(arr, n, i):    smallest = i # Initialize smallest as root    l = 2 * i + 1 # left = 2*i + 1    r = 2 * i + 2 # right = 2*i + 2     # If left child is smaller than root    if l < n and arr[l] < arr[smallest]:        smallest = l     # If right child is smaller than    # smallest so far    if r < n and arr[r] < arr[smallest]:        smallest = r     # If smallest is not root    if smallest != i:        (arr[i],         arr[smallest]) = (arr[smallest],                           arr[i])         # Recursively heapify the affected        # sub-tree        heapify(arr, n, smallest) # main function to do heap sortdef heapSort(arr, n):         # Build heap (rearrange array)    for i in range(int(n / 2) - 1, -1, -1):        heapify(arr, n, i)     # One by one extract an element    # from heap    for i in range(n-1, -1, -1):                 # Move current root to end #        arr[0], arr[i] = arr[i], arr[0]         # call min heapify on the reduced heap        heapify(arr, i, 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__':    arr = [4, 6, 3, 2, 9]    n = len(arr)     heapSort(arr, n)     print("Sorted array is ")    printArray(arr, n) # This code is contributed by PranchalK
// C# program for implementation of Heap Sortusing System; class GFG {         // To heapify a subtree rooted with    // node i which is an index in arr[],    // n is size of heap    static void heapify(int[] arr, int n, int i)    {        int smallest = i; // Initialize smallest as root        int l = 2 * i + 1; // left = 2*i + 1        int r = 2 * i + 2; // right = 2*i + 2         // If left child is smaller than root        if (l < n && arr[l] < arr[smallest])            smallest = l;         // If right child is smaller than smallest so far        if (r < n && arr[r] < arr[smallest])            smallest = r;         // If smallest is not root        if (smallest != i) {            int temp = arr[i];            arr[i] = arr[smallest];            arr[smallest] = temp;             // Recursively heapify the affected sub-tree            heapify(arr, n, smallest);        }    }     // main function to do heap sort    static void heapSort(int[] arr, int n)    {        // Build heap (rearrange array)        for (int i = n / 2 - 1; i >= 0; i--)            heapify(arr, n, i);         // One by one extract an element from heap        for (int i = n - 1; i >= 0; i--) {                         // Move current root to end            int temp = arr[0];            arr[0] = arr[i];            arr[i] = temp;             // call min heapify on the reduced heap            heapify(arr, i, 0);        }    }     /* 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 program    public static void Main()    {        int[] arr = { 4, 6, 3, 2, 9 };        int n = arr.Length;         heapSort(arr, n);         Console.WriteLine("Sorted array is ");        printArray(arr, n);    }} // This code is contributed by vt_m.
<script>  // Javascript program for implementation of Heap Sort // To heapify a subtree rooted with node i which is// an index in arr[]. n is size of heapfunction heapify(arr, n, i){    var smallest = i; // Initialize smallest as root    var l = 2 * i + 1; // left = 2*i + 1    var r = 2 * i + 2; // right = 2*i + 2     // If left child is smaller than root    if (l < n && arr[l] < arr[smallest])        smallest = l;     // If right child is smaller than smallest so far    if (r < n && arr[r] < arr[smallest])        smallest = r;     // If smallest is not root    if (smallest != i) {        [arr[i], arr[smallest]] = [arr[smallest], arr[i]]         // Recursively heapify the affected sub-tree        heapify(arr, n, smallest);    }} // main function to do heap sortfunction heapSort(arr, n){    // Build heap (rearrange array)    for (var i = parseInt(n / 2 - 1); i >= 0; i--)        heapify(arr, n, i);     // One by one extract an element from heap    for (var i = n - 1; i >= 0; i--) {        // Move current root to end        [arr[0], arr[i]] = [arr[i], arr[0]]         // call min heapify on the reduced heap        heapify(arr, i, 0);    }} /* A utility function to print array of size n */function printArray(arr, n){    for (var i = 0; i < n; ++i)        document.write( arr[i] + " ");    document.write("<br>");} // Driver programvar arr = [4, 6, 3, 2, 9];var n = arr.length;heapSort(arr, n);document.write( "Sorted array is <br>");printArray(arr, n);   </script>
Sorted array is 
9 6 4 3 2
 
Time complexity:It takes O(logn) for heapify and O(n) for constructing a heap. Hence, the overall time complexity of heap sort using min heap or max heap is O(nlogn)
Space complexity: O(n) for call stack 
PranchalKatiyar
rrrtnx
rajatkumargla19
simmytarika5
technophpfij
Heap Sort
Heap
Sorting
Sorting
Heap
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.