# Heap Sort ## HeapSort **What is** [**Binary Heap**](https://www.geeksforgeeks.org/binary-heap/)**?**\ Let us first define a Complete Binary Tree. A complete binary tree is a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible (Source [Wikipedia](http://en.wikipedia.org/wiki/Binary_tree#Types_of_binary_trees)) A [Binary Heap](https://www.geeksforgeeks.org/binary-heap/) is a Complete Binary Tree where items are stored in a special order such that value in **a parent node is greater(or smaller) than the values in its two children nodes**. The former is called as **max heap** and the latter is called **min heap**. The `heap` can be represented by `binary tree` or `array`. **Why array based representation for Binary Heap?**\ Since a Binary Heap is a Complete Binary Tree, it can be easily represented as array and array based representation is space efficient. If the parent node is stored at index `I`, the left child can be calculated by `2 * I + 1` and right child by `2 * I + 2` (assuming the indexing starts at `0`). **Heap Sort Algorithm for sorting in increasing order:**\ **1.** Build a `max heap` from the input data.\ **2.** At this point, the largest 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. **How to build the heap?**\ Heapify procedure can be applied to a node only if its children nodes are heapified. So the heapification must be performed in the bottom up order. Lets understand with the help of an example: ``` Input data: 4, 10, 3, 5, 1 4(0) / \ 10(1) 3(2) / \ 5(3) 1(4) The numbers in bracket represent the indices in the array representation of data. Applying heapify procedure to index 1: 4(0) / \ 10(1) 3(2) / \ 5(3) 1(4) Applying heapify procedure to index 0: 10(0) / \ 5(1) 3(2) / \ 4(3) 1(4) The heapify procedure calls itself recursively to build heap in top down manner. ``` ```python # Python program for implementation of heap Sort # To heapify subtree rooted at index i. # n is size of heap def 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 # See if left child of root exists and is # greater than root if l < n and arr[i] < arr[l]: largest = l # See if right child of root exists and is # greater than root if r < n and arr[largest] < arr[r]: largest = r # Change root, if needed if largest != i: arr[i],arr[largest] = arr[largest],arr[i] # swap # Heapify the root. heapify(arr, n, largest) # The main function to sort an array of given size def heapSort(arr): n = len(arr) # Build a maxheap. for i in range(n, -1, -1): heapify(arr, n, i) # One by one extract elements for i in range(n-1, 0, -1): arr[i], arr[0] = arr[0], arr[i] # swap heapify(arr, i, 0) # Driver code to test above arr = [ 12, 11, 13, 5, 6, 7] heapSort(arr) n = len(arr) print ("Sorted array is") for i in range(n): print ("%d" %arr[i]), # This code is contributed by Mohit Kumra ``` ``` Sorted array is 5 6 7 11 12 13 ``` ### LintCode problems ```python class Solution: """ @param A: an integer array @return: nothing """ def sortIntegers2(self, A): # write your code here n = len(A) # create and build heap for i in xrange(n, -1, -1): self.heapify(A, n, i) # extract elements at the root for i in xrange(n - 1, 0, -1): # Swap A[i], A[0] = A[0], A[i] # Re-Heapify self.heapify(A, i, 0) def heapify(self, A, n, i): # Ascending order -> Max Heap largest = i left = 2 * i + 1 right = 2 * i + 2 if left < n and A[largest] < A[left]: largest = left if right < n and A[largest] < A[right]: largest = right # Swap root with left or right if needed if largest != i: # Swap A[i], A[largest] = A[largest], A[i] # Re-Heapify self.heapify(A, n, largest) ``` **Notes:**\ Heap sort is an in-place algorithm.\ Its typical implementation is not stable, but can be made stable (See [this](https://www.geeksforgeeks.org/stability-in-sorting-algorithms/)) **Time Complexity:** * Time complexity of heapify is `O(Logn)`. * Time complexity of `createAndBuildHeap()` is `O(n)` * overall time complexity of Heap Sort is `O(nLogn)`. **Applications of HeapSort**\ **1.** [Sort a nearly sorted (or K sorted) array](https://www.geeksforgeeks.org/nearly-sorted-algorithm/)\ **2.** [k largest(or smallest) elements in an array](https://www.geeksforgeeks.org/k-largestor-smallest-elements-in-an-array/) Heap sort algorithm has limited uses because Quicksort and Mergesort are better in practice. Nevertheless, the Heap data structure itself is enormously used. See [Applications of Heap Data Structure](https://www.geeksforgeeks.org/applications-of-heap-data-structure/) {% embed url="" %} ### References {% embed url="" %} --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://lintcode-solutions.gitbook.io/project/cs-fundamentals/sort/heap-sort.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.