Iterative HeapSort

Difficulty Level :
Medium
HeapSort is a comparison based sorting technique where we first build Max Heap and then swaps the root element with last element (size times) and maintains the heap property each time to finally make it sorted. 
Examples:
Input :  10 20 15 17 9 21
Output : 9 10 15 17 20 21 

Input:  12 11 13 5 6 7 15 5 19
Output: 5 5 6 7 11 12 13 15 19 
In first Example, first we have to build Max Heap. 
So, we will start from 20 as child and check for its parent. Here 10 is smaller, so we will swap these two. 
Now, 20 10 15 17 9 21 
Now, child 17 is greater than its parent 10. So, both will be swapped and order will be 20 17 15 10 9 21 
Now, child 21 is greater than parent 15. So, both will be swapped. 
20 17 21 10 9 15 
Now, again 21 is bigger than parent 20. So, 21 17 20 10 9 15 
This is Max Heap. 
Now, we have to apply sorting. Here, we have to swap first element with last one and we have to maintain Max Heap property. So, after first swapping : 15 17 20 10 9 21 It clearly violates Max Heap property. 
So, we have to maintain it. So, order will be 
20 17 15 10 9 21 
17 10 15 9 20 21 
15 10 9 17 20 21 
10 9 15 17 20 21 
9 10 15 17 20 21 
Here, underlined part is sorted part.
C++
Java
Python3
C#
C
// C++ program for implementation// of Iterative Heap Sort#include <bits/stdc++.h>using namespace std; // function build Max Heap where value// of each child is always smaller// than value of their parentvoid buildMaxHeap(int arr[], int n){    for (int i = 1; i < n; i++)    {        // if child is bigger than parent        if (arr[i] > arr[(i - 1) / 2])        {            int j = i;                 // swap child and parent until            // parent is smaller            while (arr[j] > arr[(j - 1) / 2])            {                swap(arr[j], arr[(j - 1) / 2]);                j = (j - 1) / 2;            }        }    }} void heapSort(int arr[], int n){    buildMaxHeap(arr, n);     for (int i = n - 1; i > 0; i--)    {        // swap value of first indexed        // with last indexed        swap(arr[0], arr[i]);             // maintaining heap property        // after each swapping        int j = 0, index;                 do        {            index = (2 * j + 1);                         // if left child is smaller than            // right child point index variable            // to right child            if (arr[index] < arr[index + 1] &&                                index < (i - 1))                index++;                     // if parent is smaller than child            // then swapping parent with child            // having higher value            if (arr[j] < arr[index] && index < i)                swap(arr[j], arr[index]);                     j = index;                 } while (index < i);    }} // Driver Code to test aboveint main(){    int arr[] = {10, 20, 15, 17, 9, 21};    int n = sizeof(arr) / sizeof(arr[0]);         printf("Given array: ");    for (int i = 0; i < n; i++)        printf("%d ", arr[i]);             printf("\n\n");     heapSort(arr, n);     // print array after sorting    printf("Sorted array: ");    for (int i = 0; i < n; i++)        printf("%d ", arr[i]);     return 0;}
// Java implementation of Iterative Heap Sortpublic class HeapSort {   // function build Max Heap where value  // of each child is always smaller  // than value of their parent  static void buildMaxHeap(int arr[], int n)  {    for (int i = 1; i < n; i++)    {      // if child is bigger than parent      if (arr[i] > arr[(i - 1) / 2])      {        int j = i;         // swap child and parent until        // parent is smaller        while (arr[j] > arr[(j - 1) / 2])        {          swap(arr, j, (j - 1) / 2);          j = (j - 1) / 2;        }      }    }  }   static void heapSort(int arr[], int n)  {    buildMaxHeap(arr, n);     for (int i = n - 1; i > 0; i--)    {      // swap value of first indexed      // with last indexed      swap(arr, 0, i);       // maintaining heap property      // after each swapping      int j = 0, index;       do      {        index = (2 * j + 1);         // if left child is smaller than        // right child point index variable        // to right child        if (index < (i - 1) && arr[index] < arr[index + 1])          index++;         // if parent is smaller than child        // then swapping parent with child        // having higher value        if (index < i && arr[j] < arr[index])          swap(arr, j, index);         j = index;       } while (index < i);    }  }   public static void swap(int[] a, int i, int j) {    int temp = a[i];    a[i]=a[j];    a[j] = temp;  }   /* A utility function to print array of size n */  static void printArray(int arr[])  {    int n = arr.length;    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[] = {10, 20, 15, 17, 9, 21};    int n = arr.length;     System.out.print("Given array: ");    printArray(arr);     heapSort(arr, n);     System.out.print("Sorted array: ");    printArray(arr);  }}
# Python3 program for implementation# of Iterative Heap Sort # function build Max Heap where value# of each child is always smaller# than value of their parentdef buildMaxHeap(arr, n):     for i in range(n):                 # if child is bigger than parent        if arr[i] > arr[int((i - 1) / 2)]:            j = i                 # swap child and parent until            # parent is smaller            while arr[j] > arr[int((j - 1) / 2)]:                (arr[j],                 arr[int((j - 1) / 2)]) = (arr[int((j - 1) / 2)],                                           arr[j])                j = int((j - 1) / 2) def heapSort(arr, n):     buildMaxHeap(arr, n)     for i in range(n - 1, 0, -1):                 # swap value of first indexed        # with last indexed        arr[0], arr[i] = arr[i], arr[0]             # maintaining heap property        # after each swapping        j, index = 0, 0                 while True:            index = 2 * j + 1                         # if left child is smaller than            # right child point index variable            # to right child            if (index < (i - 1) and                arr[index] < arr[index + 1]):                index += 1                     # if parent is smaller than child            # then swapping parent with child            # having higher value            if index < i and arr[j] < arr[index]:                arr[j], arr[index] = arr[index], arr[j]                     j = index            if index >= i:                break # Driver Codeif __name__ == '__main__':    arr = [10, 20, 15, 17, 9, 21]    n = len(arr)         print("Given array: ")    for i in range(n):        print(arr[i], end = " ")             print()     heapSort(arr, n)     # print array after sorting    print("Sorted array: ")    for i in range(n):        print(arr[i], end = " ") # This code is contributed by PranchalK
// C# implementation of Iterative Heap Sortusing System;     class HeapSort{ // function build Max Heap where value// of each child is always smaller// than value of their parentstatic void buildMaxHeap(int []arr, int n){    for (int i = 1; i < n; i++)    {        // if child is bigger than parent        if (arr[i] > arr[(i - 1) / 2])        {            int j = i;                 // swap child and parent until            // parent is smaller            while (arr[j] > arr[(j - 1) / 2])            {                swap(arr, j, (j - 1) / 2);                j = (j - 1) / 2;            }        }    }} static void heapSort(int []arr, int n){    buildMaxHeap(arr, n);     for (int i = n - 1; i > 0; i--)    {                 // swap value of first indexed        // with last indexed        swap(arr, 0, i);             // maintaining heap property        // after each swapping        int j = 0, index;             do        {            index = (2 * j + 1);                 // if left child is smaller than            // right child point index variable            // to right child            if (index < (i - 1) && arr[index] <                                   arr[index + 1])            index++;                 // if parent is smaller than child            // then swapping parent with child            // having higher value            if (index < i && arr[j] < arr[index])                swap(arr, j, index);                 j = index;             } while (index < i);    }} public static void swap(int[] a, int i, int j){    int temp = a[i];    a[i] = a[j];    a[j] = temp;} /* A utility function to print array of size n */static void printArray(int []arr){    int n = arr.Length;    for (int i = 0; i < n; i++)    Console.Write(arr[i] + " ");    Console.WriteLine();} // Driver Codepublic static void Main(String []args){    int []arr = {10, 20, 15, 17, 9, 21};    int n = arr.Length;     Console.Write("Given array: ");    printArray(arr);     heapSort(arr, n);     Console.Write("Sorted array: ");    printArray(arr);}} // This code is contributed by Princi Singh
// C program for implementation// of Iterative Heap Sort#include <stdio.h> // function build Max Heap where value// of each child is always smaller// than value of their parentvoid buildMaxHeap(int arr[], int n){    for (int i = 1; i < n; i++)    {        // if child is bigger than parent        if (arr[i] > arr[(i - 1) / 2])        {            int j = i;                 // swap child and parent until            // parent is smaller            while (arr[j] > arr[(j - 1) / 2])            {                int temp=arr[j];                arr[j]=arr[(j-1)/2];                arr[(j-1)/2]=temp;                j = (j - 1) / 2;            }        }    }} void heapSort(int arr[], int n){    buildMaxHeap(arr, n);     for (int i = n - 1; i > 0; i--)    {        // swap value of first indexed        // with last indexed        int temp=arr[0];        arr[0]=arr[i];        arr[i]=temp;             // maintaining heap property        // after each swapping        int j = 0, index;                 do        {            index = (2 * j + 1);                         // if left child is smaller than            // right child point index variable            // to right child            if (arr[index] < arr[index + 1] &&                                index < (i - 1))                index++;                     // if parent is smaller than child            // then swapping parent with child            // having higher value            if (arr[j] < arr[index] && index < i)            {                int tem1=arr[j];                arr[j]=arr[index];                arr[index]=tem1;            }                     j = index;                 } while (index < i);    }} // Driver Code to test aboveint main(){    int arr[] = {10, 20, 15, 17, 9, 21};    int n = sizeof(arr) / sizeof(arr[0]);         printf("Given array: ");    for (int i = 0; i < n; i++)        printf("%d ", arr[i]);             printf("\n\n");     heapSort(arr, n);     // print array after sorting    printf("Sorted array: ");    for (int i = 0; i < n; i++)        printf("%d ", arr[i]);     return 0;}
Output :
Given array: 10 20 15 17 9 21 

Sorted array: 9 10 15 17 20 21 
Here, both function buildMaxHeap and heapSort runs in O(nlogn) time. So, overall time complexity is O(nlogn)
PranchalKatiyar
vreflect
Rajput-Ji
rexomkar
Heap
Sorting
Sorting
Heap
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
K'th Smallest/Largest Element in Unsorted Array | Set 1
Binary Heap
Introduction to Data Structures
Huffman Coding | Greedy Algo-3
Sliding Window Maximum (Maximum of all subarrays of size k)
Count Inversions in an array | Set 1 (Using Merge Sort)
Merge two sorted arrays
Sort an array of 0s, 1s and 2s | Dutch National Flag problem
Chocolate Distribution Problem
Find a triplet that sum to a given value