Learn Python – Heap Sort in Python- Basic and advance

The heap kind is quite the identical as the determination sort, where we locate the most component and put it at the end. It is based totally on a contrast sorting algorithm which works on Binary heap statistics structure. It is the nice instance of an efficient sorting algorithm.

What is Heap Sort?

Heap type is an efficient and famous sorting algorithm. The heap kind concept is to “eliminate” the aspect from the heap section of the listing one-by-one and insert them to the sorted phase of the list. Before mastering greater about the heap sorting algorithm, let’s talk about the heap statistics structure.

It is an in-place algorithm, which potential a fixed quantity of reminiscence is used to shop the sorted list, or the reminiscence dimension does not remember on the dimension of the preliminary list.

For example – We don’t want the extra reminiscence stack to store the sorted array and neither recursive call stack. The heapsort algorithm commonly implements the use of the 2d array to kind the fixed values. This system is quick, simple, herbal and effortless to implement.

On the other hand, heap sort is unstable, which capacity it does not hold the comparative order of elements with equal values. It can rapidly kind primitive sorts such as integers and characters, but it has a trouble with the complex kinds and objects.

Let’s understand it by the following example –

We have a custom class Student with houses age and name, and quite a few objects of that category in an array, which include a pupil known as “Thomas” a long time “20” and additionally “Peter,” have aged 20 show up in the identical order.

If we sort the array of humans by age, then there is no warranty that “Thomas” would appear earlier than the “Peter” in the sorted array. It can be defined order, however there is no guarantee.

Heap Data Structure

The heap records structure is a entire binary tree that fulfills the heap property. It is additionally known as the binary heap.

A whole binary tree satisfies the following properties.

Every level should be filled.

All the nodes are as far left as possible.

As we can see in the above image of the heap, but it is now not sorted. We will no longer dig in-depth this article due to the fact our center of attention is to explain the Heap type algorithm, now not a heap. In the heap sort, the subsequent smallest thing is constantly the first element.

The heap tree can be the two types – min-heap and max tree. A min-heap is saved a record of the maximum element. A max heap maintains song of the biggest element. Heap generally helps the following operations – delete_minimum(), get_minimum() and add().

The first thing of the heap can delete after restoring it. It takes O(log N) time, and that is fairly effective.


Python presents the in-built functions for sorting factors the usage of heap sort. The features are given below.

heappush(list, item) -It is used to add the heap element and re-sort it.

heappop(list) – It is used to remove the element and return the element.

heapfy() – It is used to turn the given list into a heap.

Consider the following example for heap sort.

Example –

from heapq import heappop, heappush  
 def heapsort(list1):  
     heap = []  
     for ele in list1:  
         heappush(heap, ele)  
     sort = []  
     # the elements are lift in the heap  
     while heap:  
     return sort  
 list1 = [27, 21, 55, 15, 60, 4, 11, 17, 2, 87]  


[2, 4, 11, 15, 17, 21, 27, 55, 60, 87]


In the above code, we have imported the heapq module which consist heappop() and heappush() method. We created the Heapsort Heapsort () method, which takes list1 as an argument. A for loop iterated the list1 and pushed the elements to the empty heap. We used the while loop and sorted component delivered to the empty sort.

We called the Heapsort Heapsort () function and exceeded a list. It back the sorted list.

Sorting Custom Objects

Heap type is beneficial for predefined information types, but it is greater intricate to manage the user-define records types, such as type objects. We will type the customized objects in this section.

As we can see, our implementation depends upon the built-in methods. Python affords the following methods.

heapq.nlargest(*n*, *iterable*, *key = None) – This method is used to get a list with the n largest element from the dataset, defined by the iterable.

heapq.nsmallest(*n*, *iterable*, *key = None) – This method is used to get a list with the n smallest elements from the dataset, which is defined by the iterable.

Let’s understand the following implementation of customized objects.

Example –

from heapq import heappop, heappush  
 class Car:  
     def __init__(self, model, year):  
         self.model = model  
         self.year = year  
     def __str__(self):  
         return str.format("Model Name: {}, Year: {}", self.model, self.year)  
     def __lt__(self, other):  
         return self.year < other.year  
     def __gt__(self, other):  
         return other.__lt__(self)  
     def __eq__(self, other):  
         return self.year == other.year  
     def __ne__(self, other):  
         return not self.__eq__(other)  
 def heapsort(list1):  
     heap = []  
     for element in list1:  
         heappush(heap, element)  
     ordered = []  
     while heap:  
     return ordered  
 car1 = Car("Renault", 2001)  
 car2 = Car("Bentley", 2005)  
 car3 = Car("Kia", 2014)  
 car4 = Car("Maruti Suzuki", 1999);  
 car5 = Car("Nano", 2012)  
 list1 = [car1, car2, car3, car4, car5]  
 for c in Heapsort Heapsort (list1):  


Model Name: Maruti Suzuki, Year: 1999
Model Name: Renault, Year: 2001
Model Name: Bentley, Year: 2005
Model Name: Nano, Year: 2012
Model Name: Kia, Year: 2014

We have sorted the objects on the year base.

Comparison between Heap sort and Other Algorithm

One of the famous quick type algorithms is additionally very efficient, but heap type is legally used because of its reliability. The heap sort’s key advantage is O(nlogn) upper certain as far as the time complexity is fretful.

The heap kind algorithm takes O(nlogn) time in each common and worst-case eventualities whilst the speedy sort is 20% quicker in the average case.

The quick kind algorithm becomes slow in predictable situations. There is a hazard of the protection breach in quick sort on the grounds that the foul O(n2) can be without problems triggered.

Now we compare to the Merge sort, which takes the equal time as the heap sort.

Merge kind is a lot steady and intuitively parallelizable, the place heap type does not have such advantages.

Furthermore, Merge type is faster than the Heap Sort in most cases considering they have the equal time complexity.

In contrast, HeapsortHeapsort can be applied lots rapidly in-place than Marge sort can.


Heapsort is no longer so famous and faster, but it is greater predictable than any different sorting algorithm. This algorithm is preferred the place memory and safety are a priority.

It can be shortly implemented using Python. We require to insert the elements in a heap and take them out.