Heap Sort Complexity

Time Complexity

Best O(nlog n)

Worst O(nlog n)

Average O(nlog n)

Space Complexity O(1)

Stability No

Heap Sort has O(nlog n) time complexities for all the cases ( best case,
average case, and worst case).
Let us understand the reason why. The height of a complete binary tree
containing n elements is log n

As we have seen earlier, to fully heapify an element whose subtrees are

already max-heaps, we need to keep comparing the element with its left
and right children and pushing it downwards until it reaches a point where
both its children are smaller than it.

In the worst case scenario, we will need to move an element from the root
to the leaf node making a multiple of log(n) comparisons and swaps.
During the build_max_heap stage, we do that for n/2 elements so the worst
case complexity of the build_heap step is n/2*log n ~ nlog n .
During the sorting step, we exchange the root element with the last element
and heapify the root element. For each element, this again takes log

n worst time because we might have to bring the element all the way from
the root to the leaf. Since we repeat this n times, the heap_sort step is
also nlog n .

Also since the build_max_heap and heap_sort steps are executed one after
another, the algorithmic complexity is not multiplied and it remains in the
order of nlog n .

Also it performs sorting in O(1) space complexity. Compared with Quick

Sort, it has a better worst case ( O(nlog n) ) . Quick Sort has
complexity O(n^2) for worst case. But in other cases, Quick Sort is fast.
Introsort is an alternative to heapsort that combines quicksort and heapsort
to retain advantages of both: worst case speed of heapsort and average
speed of quicksort.

Applications of Heap Sort Algorithm

1. Sorting: Heap sort can efficiently sort an array of elements in
ascending or descending order. It has a worst-case time complexity of
O(n log n), which makes it suitable for sorting large data sets.
2. Priority Queue: Heap sort can be used to implement a priority queue,
where each element has a priority associated with it. The heap structure
allows for the efficient insertion and extraction of elements based on
their priority.
3. Selection of Top-K Elements: Heap sort can be used to efficiently find
the top-k elements from a large dataset. By building a max-heap, the k
largest elements can be extracted in O(k log n) time complexity.
4. Median Finding: Heap sort can be employed to find the median of a
dataset. By using two heaps (a max-heap for the lower half of elements
and a min-heap for the upper half), the median can be determined in
O(log n) time complexity for each element.
5. External Sorting: Heap sort can be used in external sorting algorithms,
where data is too large to fit entirely in memory. It can be applied in the
initial phase of sorting, where chunks of data are sorted and written
back to the disk before merging them.

Advantages of Heap Sort Algorithm

 1. Efficiency: Heap sort has a time complexity of O(n log n) in all cases,
where 'n' is the number of elements to be sorted. This makes it more
efficient than many other sorting algorithms, such as bubble
sort or insertion sort, which have higher time complexities in the worst
case.
2. Space efficiency: Heap sort sorts the elements in place, meaning it
does not require additional memory proportional to the number of
elements being sorted. It achieves this by utilizing the original array to
build a binary heap and then performing in-place swaps to sort the
elements.
3. Guaranteed worst-case performance: Unlike some other sorting
algorithms, such as quicksort, which have a worst-case time
complexity of O(n^2) in certain scenarios, heap sort guarantees a worst-
case time complexity of O(n log n) regardless of the input data
distribution. This predictability makes it a reliable choice in situations
where worst-case performance is critical.
4. In-place sorting: As mentioned earlier, heap sort performs sorting in
place, which means it does not require additional memory beyond the
input array. This makes it suitable for situations where memory usage is
a concern or when working with large datasets that may not fit into
available memory.
5. Stability: It preserves the relative order of elements with equal keys.
This property can be important in certain applications where maintaining
the original order of elements is necessary.
6. Simplicity: The basic concept of the heap sort is relatively simple to
understand compared to some other advanced sorting algorithms. It
involves building a binary heap and repeatedly extracting the maximum
(or minimum) element from the heap to construct the sorted array.
7. Partial sorting: Heap sort can be easily modified to perform partial
sorting, where only the top k elements are sorted, rather than the entire
array. This feature can be useful in situations where only a subset of the
largest or smallest elements is required

Disadvantages of Heap Sort Algorithm

1. Not a stable sorting algorithm: Heap sort does not guarantee the
relative order of elements with equal keys. If there are duplicate
elements in the input array, their order may change after sorting. This
makes heap sort unsuitable for sorting certain types of data where
stability is important.
2. Requires additional space: Heap sort requires additional space to
build the heap data structure. The sorting algorithm itself is an in-place
algorithm, meaning it sorts the elements within the input array without
requiring additional memory. However, creating the heap initially
requires a separate heap data structure, which can consume extra
 memory. This extra space requirement can be a disadvantage when
working with large data sets.
3. Poor cache performance: This is because heap sort accesses
memory in a non-sequential manner, jumping between different parts of
the heap. This irregular memory access pattern can lead to cache
misses and slower performance, particularly when sorting large arrays.
4. The complexity of implementation: Building the heap and performing
the heapify operation to maintain the heap property requires careful
implementation. This complexity can make heap sorting harder to
understand and debug, especially for novice programmers.
5. Not adaptive: Heap sort does not take advantage of any existing order
in the input array. It always performs the same number of comparisons
and swaps regardless of the initial order of the elements. This lack of
adaptivity makes it less efficient than some other sorting algorithms
when applied to partially sorted or nearly sorted arrays.