Skip to content

Iterative HeapSort

Heap Sort - Data Structures and Algorithms Tutorials

Last Updated : 02 Jan, 2025

Try it on GfG Practice

Heap sort is a comparison-based sorting technique based on Binary Heap Data Structure. It can be seen as an optimization over selection sort where we first find the max (or min) element and swap it with the last (or first). We repeat the same process for the remaining elements. In Heap Sort, we use Binary Heap so that we can quickly find and move the max element in O(Log n) instead of O(n) and hence achieve the O(n Log n) time complexity.

Table of Content

Heap Sort Algorithm

First convert the array into a max heap using heapify, Please note that this happens in-place. The array elements are re-arranged to follow heap properties. Then one by one delete the root node of the Max-heap and replace it with the last node and heapify. Repeat this process while size of heap is greater than 1.

Rearrange array elements so that they form a Max Heap.
Repeat the following steps until the heap contains only one element:
- Swap the root element of the heap (which is the largest element in current heap) with the last element of the heap.
- Remove the last element of the heap (which is now in the correct position). We mainly reduce heap size and do not remove element from the actual array.
- Heapify the remaining elements of the heap.
Finally we get sorted array.

Detailed Working of Heap Sort

Step 1: Treat the Array as a Complete Binary Tree

We first need to visualize the array as a complete binary tree. For an array of size n, the root is at index 0, the left child of an element at index i is at 2i + 1, and the right child is at 2i + 2.

Visualize-the-array-as-a-complete-binary-tree

Step 2: Build a Max Heap

Step 3: Sort the array by placing largest element at end of unsorted array.

In the illustration above, we have shown some steps to sort the array. We need to keep repeating these steps until there’s only one element left in the heap.

Implementation of Heap Sort

C++

// C++ program for implementation of Heap Sort using vector  #include <bits/stdc++.h> using namespace std;  // To heapify a subtree rooted with node i // which is an index in arr[]. void heapify(vector<int>& arr, int n, int i){      // Initialize largest as root     int largest = i;      // left index = 2*i + 1     int l = 2 * i + 1;      // right index = 2*i + 2     int r = 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);     } }  // Main function to do heap sort void heapSort(vector<int>& arr){     int n = arr.size();      // Build heap (rearrange vector)     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 max heapify on the reduced heap         heapify(arr, i, 0);     } }  // A utility function to print vector of size n void printArray(vector<int>& arr){     for (int i = 0; i < arr.size(); ++i)         cout << arr[i] << " ";     cout << "\n"; }  // Driver's code int main(){     vector<int> arr = { 9, 4, 3, 8, 10, 2, 5 };      // Function call     heapSort(arr);      cout << "Sorted array is \n";     printArray(arr); }

C

#include <stdio.h>  // To heapify a subtree rooted with node i // which is an index in arr[]. void heapify(int arr[], int n, int i) {      // Initialize largest as root     int largest = i;       // left index = 2*i + 1     int l = 2 * i + 1;       // right index = 2*i + 2     int r = 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 temp = arr[i];         arr[i] = arr[largest];         arr[largest] = temp;          // Recursively heapify the affected sub-tree         heapify(arr, n, largest);     } }  // Main function to do heap sort 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 max 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++) {         printf("%d ", arr[i]);     }     printf("\n"); }  // Driver's code int main() {     int arr[] = {9, 4, 3, 8, 10, 2, 5};      int n = sizeof(arr) / sizeof(arr[0]);      heapSort(arr, n);      printf("Sorted array is \n");     printArray(arr, n);     return 0; }

Java

import java.util.Arrays;  class GfG {        // To heapify a subtree rooted with node i     // which is an index in arr[].     static void heapify(int arr[], int n, int i) {          // Initialize largest as root         int largest = i;           // left index = 2*i + 1         int l = 2 * i + 1;           // right index = 2*i + 2         int r = 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 temp = arr[i];             arr[i] = arr[largest];             arr[largest] = temp;              // Recursively heapify the affected sub-tree             heapify(arr, n, largest);         }     }      // Main function to do heap sort     static void heapSort(int arr[]) {         int n = arr.length;          // 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 max heapify on the reduced heap             heapify(arr, i, 0);         }     }      // A utility function to print array of size n     static void printArray(int arr[]) {         for (int i = 0; i < arr.length; i++) {             System.out.print(arr[i] + " ");         }         System.out.println();     }      // Driver's code     public static void main(String args[]) {         int arr[] = {9, 4, 3, 8, 10, 2, 5};          heapSort(arr);         System.out.println("Sorted array is ");         printArray(arr);     } }

Python

# Python program for implementation of heap Sort  # To heapify a subtree rooted with node i # which is an index in arr[]. def heapify(arr, n, i):           # Initialize largest as root     largest = i           #  left index = 2*i + 1     l = 2 * i + 1           # right index = 2*i + 2     r = 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]  # Swap          # Recursively heapify the affected sub-tree         heapify(arr, n, largest)  # Main function to do heap sort def heapSort(arr):          n = len(arr)       # Build heap (rearrange array)     for i in range(n // 2 - 1, -1, -1):         heapify(arr, n, i)      # One by one extract an element from heap     for i in range(n - 1, 0, -1):                # Move root to end         arr[0], arr[i] = arr[i], arr[0]           # Call max heapify on the reduced heap         heapify(arr, i, 0)  def printArray(arr):     for i in arr:         print(i, end=" ")     print()  # Driver's code arr = [9, 4, 3, 8, 10, 2, 5]  heapSort(arr) print("Sorted array is ") printArray(arr)

C#

using System;  class GfG {     // To heapify a subtree rooted with node i     // which is an index in arr[].     static void Heapify(int[] arr, int n, int i) {                 // Initialize largest as root         int largest = i;                // left index = 2*i + 1         int l = 2 * i + 1;                 // right index = 2*i + 2         int r = 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 temp = arr[i]; // Swap             arr[i] = arr[largest];             arr[largest] = temp;              // Recursively heapify the affected sub-tree             Heapify(arr, n, largest);         }     }      // Main function to do heap sort     static void HeapSortArray(int[] arr) {         int n = arr.Length;          // 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 max heapify on the reduced heap             Heapify(arr, i, 0);         }     }      // A utility function to print array of size n     static void PrintArray(int[] arr) {         foreach (int value in arr) {             Console.Write(value + " ");         }         Console.WriteLine();     }      // Driver's code     public static void Main(string[] args) {         int[] arr = {9, 4, 3, 8, 10, 2, 5};         HeapSortArray(arr);         Console.WriteLine("Sorted array is ");         PrintArray(arr);     } }

JavaScript

// To heapify a subtree rooted with node i // which is an index in arr[]. function heapify(arr, n, i) {      // Initialize largest as root     let largest = i;          // left index = 2*i + 1     let l = 2 * i + 1;           // right index = 2*i + 2     let r = 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 temp = arr[i]; // Swap         arr[i] = arr[largest];         arr[largest] = temp;          // Recursively heapify the affected sub-tree         heapify(arr, n, largest);     } }  // Main function to do heap sort function heapSort(arr) {     let n = arr.length;      // Build heap (rearrange array)     for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {         heapify(arr, n, i);     }      // One by one extract an element from heap     for (let i = n - 1; i > 0; i--) {              // Move current root to end         let temp = arr[0];         arr[0] = arr[i];         arr[i] = temp;          // Call max heapify on the reduced heap         heapify(arr, i, 0);     } }  // A utility function to print array of size n function printArray(arr) {     for (let i = 0; i < arr.length; i++) {         console.log(arr[i] + " ");     }     console.log(); }  // Driver's code let arr = [9, 4, 3, 8, 10, 2, 5]; heapSort(arr); console.log("Sorted array is "); printArray(arr);

PHP

<?php  // To heapify a subtree rooted with node i // which is an index in arr[]. function heapify(&$arr, $n, $i) {        // Initialize largest as root     $largest = $i;         // left index = 2*i + 1     $l = 2 * $i + 1;        // right index = 2*i + 2     $r = 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) {         $temp = $arr[$i]; // Swap         $arr[$i] = $arr[$largest];         $arr[$largest] = $temp;          // Recursively heapify the affected sub-tree         heapify($arr, $n, $largest);     } }  // Main function to do heap sort function heapSort(&$arr) {     $n = count($arr);      // Build heap (rearrange array)     for ($i = intval($n / 2) - 1; $i >= 0; $i--) {         heapify($arr, $n, $i);     }      // One by one extract an element from heap     for ($i = $n - 1; $i > 0; $i--) {                // Move current root to end         $temp = $arr[0];          $arr[0] = $arr[$i];         $arr[$i] = $temp;          // Call max heapify on the reduced heap         heapify($arr, $i, 0);     } }  // A utility function to print array of size n function printArray($arr) {     foreach ($arr as $value) {         echo $value . " ";     }     echo "\n"; }  // Driver's code $arr = [9, 4, 3, 8, 10, 2, 5]; heapSort($arr); echo "Sorted array is:\n"; printArray($arr); ?>

Output

Sorted array is  2 3 4 5 8 9 10

Complexity Analysis of Heap Sort

Time Complexity: O(n log n)
Auxiliary Space: O(log n), due to the recursive call stack. However, auxiliary space can be O(1) for iterative implementation.

Important points about Heap Sort

Heap sort is an in-place algorithm.
Its typical implementation is not stable but can be made stable (See this)
Typically 2-3 times slower than well-implemented QuickSort. The reason for slowness is a lack of locality of reference.

Advantages of Heap Sort

Efficient Time Complexity: Heap Sort has a time complexity of O(n log n) in all cases. This makes it efficient for sorting large datasets. The log n factor comes from the height of the binary heap, and it ensures that the algorithm maintains good performance even with a large number of elements.
Memory Usage: Memory usage can be minimal (by writing an iterative heapify() instead of a recursive one). So apart from what is necessary to hold the initial list of items to be sorted, it needs no additional memory space to work
Simplicity: It is simpler to understand than other equally efficient sorting algorithms because it does not use advanced computer science concepts such as recursion.

Disadvantages of Heap Sort

Costly: Heap sort is costly as the constants are higher compared to merge sort even if the time complexity is O(n Log n) for both.
Unstable: Heap sort is unstable. It might rearrange the relative order.
Inefficient: Heap Sort is not very efficient because of the high constants in the time complexity.

Iterative HeapSort

K

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

Heap Sort - Data Structures and Algorithms Tutorials

Heap sort is a comparison-based sorting technique based on Binary Heap Data Structure. It can be seen as an optimization over selection sort where we first find the max (or min) element and swap it with the last (or first). We repeat the same process for the remaining elements. In Heap Sort, we use

Iterative HeapSort

HeapSort is a comparison-based sorting technique where we first build Max Heap and then swap the root element with the 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

Java Program for Heap Sort

Heap sort is a comparison-based sorting technique based on the Binary Heap data structure. It is similar to the selection sort where first find the maximum element and place it at the end. We repeat the same process for the remaining element. Heap Sort in JavaBelow is the implementation of Heap Sort

C++ Program for Heap Sort

Heap sort is a comparison-based sorting technique based on the Binary Heap data structure. It is similar to the selection sort where we first find the maximum element and place the maximum element at the end. We repeat the same process for the remaining element. Recommended PracticeHeap SortTry It!

sort_heap function in C++

The sort_heap( ) is an STL algorithm which sorts a heap within the range specified by start and end. Sorts the elements in the heap range [start, end) into ascending order. The second form allows you to specify a comparison function that determines when one element is less than another. Defined in h

Heap Sort - Python

Heapsort is a comparison-based sorting technique based on a Binary Heap data structure. It is similar to selection sort where we first find the maximum element and place the maximum element at the end. We repeat the same process for the remaining element.Heap Sort AlgorithmFirst convert the array in

Lexicographical ordering using Heap Sort

Given an array arr[] of strings. The task is to sort the array in lexicographical order using Heap Sort.Examples: Input: arr[] = { "banana", "apple", "mango", "pineapple", "orange" } Output: apple banana mango orange pineappleInput: arr[] = { "CAB", "ACB", "ABC", "CBA", "BAC" } Output: ABC, ACB, BAC

Heap sort for Linked List

Given a linked list, the task is to sort the linked list using HeapSort. Examples: Input: list = 7 -> 698147078 -> 1123629290 -> 1849873707 -> 1608878378 -> 140264035 -> -1206302000Output: -1206302000 -> 7 -> 140264035 -> 1123629290 -> 1608878378 -> 1698147078 ->1

Python Code for time Complexity plot of Heap Sort

Prerequisite : HeapSort Heap sort is a comparison based sorting technique based on Binary Heap data structure. It is similar to selection sort where we first find the maximum element and place the maximum element at the end. We repeat the same process for remaining element. We implement Heap Sort he

Sorting algorithm visualization : Heap Sort

An algorithm like Heap sort can be understood easily by visualizing. In this article, a program that visualizes the Heap Sort Algorithm has been implemented. The Graphical User Interface(GUI) is implemented in Python using pygame library. Approach: Generate random array and fill the pygame window wi