A priority queue is common use for a heap, and it presents several implementation challenges:,Sort stability: how do you get two tasks with equal priorities to be returned in the order they were originally added?,This module provides an implementation of the heap queue algorithm, also known as the priority queue algorithm.,Removing the entry or changing its priority is more difficult because it would break the heap structure invariants. So, a possible solution is to mark the entry as removed and add a new entry with the revised priority:

```
>>> def heapsort(iterable):
...h = []
...
for value in iterable:
...heappush(h, value)
...
return [heappop(h) for i in range(len(h))]
...
>>>
heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

```
>>> h = [] >>>
heappush(h, (5, 'write code')) >>>
heappush(h, (7, 'release product')) >>>
heappush(h, (1, 'write spec')) >>>
heappush(h, (3, 'create tests')) >>>
heappop(h)
(1, 'write spec')
```

```
from dataclasses
import dataclass, field
from typing
import Any
@dataclass(order = True)
class PrioritizedItem:
priority: int
item: Any = field(compare = False)
```

```
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = '<removed-task>' # placeholder for a removed task
counter = itertools.count() # unique sequence count
def add_task(task, priority=0):
'Add a new task or update the priority of an existing task'
if task in entry_finder:
remove_task(task)
count = next(counter)
entry = [priority, count, task]
entry_finder[task] = entry
heappush(pq, entry)
def remove_task(task):
'Mark an existing task as REMOVED. Raise KeyError if not found.'
entry = entry_finder.pop(task)
entry[-1] = REMOVED
def pop_task():
'Remove and return the lowest priority task. Raise KeyError if empty.'
while pq:
priority, count, task = heappop(pq)
if task is not REMOVED:
del entry_finder[task]
return task
raise KeyError('pop from an empty priority queue')
```

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

In Heap Sort, we are using a Binary Search Tree for sorting. In this, all elements are inserted into a tree. Heap sort requires more space than other sorting methods. It is a stable sort and requires constant space for sorting. The heap tree can be of two types- Max Tree and Min Tree.,It erases the smallest element from the heap and then inserts a new item. This function is more efficient than calling heappop() and heappush(). The syntax of heapreplace() is-,Max Tree- The root node has the highest key value, then the child node elements.,In the second phase, it repeatedly deletes the root element from the heap that was built in the first phase and place the element in the last empty location of the array.

First, we need to import this using the following command-

`import heapq`

Here is the simple example of Python **heapq** module to find three largest numbers and three smallest numbers from the list.

import heapq as hq lists = [19, 39, 78, 29, 52, 11, 23] # Get three largest values largest_values = hq.nlargest(3, lists) # Get three smallest values smallest_values = hq.nsmallest(3, lists) print("Three largest numbers are: ", largest_values) print("Three smallest numbers are: ", smallest_values)

**Output of the above code-**

Three largest numbers are: [78, 52, 39] Three smallest numbers are: [11, 19, 23]

Here, we have mentioned the example of the **heappush()** method.

import heapq as hq heap_elems = [19, 39, 78, 29, 52, 11, 23] print("The elements of head are: ", end = "") print(list(heap_elems)) # push elements into heap hq.heappush(heap_elems, 33) print("The modified heap after push is : ", end = "") print(list(heap_elems))

The Python **heapq** module defines **heappop()** method to pop the smallest element while protecting the heap property. The syntax is -

heappop(heap)

Last Updated : 15 Jul, 2022

**Output :**

The created heap is: [1, 3, 9, 7, 5] The modified heap after push is: [1, 3, 4, 7, 5, 9] The popped and smallest element is: 1

```
The popped item using heappushpop() is: 1
The popped item using heapreplace() is: 3
```

```
The popped item using heappushpop() is: 1
The popped item using heapreplace() is: 3
```

Now that we know this, the implementation for Heap Sort is fairly straight-forward:

```
from heapq
import heappop, heappush
def heap_sort(array):
heap = []
for element in array:
heappush(heap, element)
ordered = []
# While we have elements left in the heap
while heap:
ordered.append(heappop(heap))
return ordered
array = [13, 21, 15, 5, 26, 4, 17, 18, 24, 2]
print(heap_sort(array))
```

Output:

`[2, 4, 5, 13, 15, 17, 18, 21, 24, 26]`

However, it does let us demonstrate using Heap Sort on custom classes. Let's go ahead and define the `Movie`

class:

```
from heapq
import heappop, heappush
class Movie:
def __init__(self, title, year):
self.title = title
self.year = year
def __str__(self):
return str.format("Title: {}, Year: {}", self.title, 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)
```

And finally, let's instantiate a few movies, put them in an array, and then sort them:

```
movie1 = Movie("Citizen Kane", 1941)
movie2 = Movie("Back to the Future", 1985)
movie3 = Movie("Forrest Gump", 1994)
movie4 = Movie("The Silence of the Lambs", 1991);
movie5 = Movie("Gia", 1998)
array = [movie1, movie2, movie3, movie4, movie5]
for movie in heap_sort(array):
print(movie)
```

Heaps are binary trees for which every parent node has a value less than or equal to any of its children. This implementation uses arrays for which heap[k] <= heap[2*k+1] and heap[k] <= heap[2*k+2] for all k, counting elements from zero. For the sake of comparison, non-existing elements are considered to be infinite. The interesting property of a heap is that its smallest element is always the root, heap[0].,Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for all k, counting elements from 0. For the sake of comparison, non-existing elements are considered to be infinite. The interesting property of a heap is that a[0] is always its smallest element.,A priority queue is common use for a heap, and it presents several implementation challenges:,Heap elements can be tuples. This is useful for assigning comparison values (such as task priorities) alongside the main record being tracked:

```
>>> def heapsort(iterable):
...h = []
...
for value in iterable:
...heappush(h, value)
...
return [heappop(h) for i in range(len(h))]
...
>>>
heapsort([1, 3, 5, 7, 9, 2, 4, 6, 8, 0])[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```

```
>>> h = [] >>>
heappush(h, (5, 'write code')) >>>
heappush(h, (7, 'release product')) >>>
heappush(h, (1, 'write spec')) >>>
heappush(h, (3, 'create tests')) >>>
heappop(h)
(1, 'write spec')
```

```
pq = [] # list of entries arranged in a heap
entry_finder = {} # mapping of tasks to entries
REMOVED = '<removed-task>' # placeholder for a removed task
counter = itertools.count() # unique sequence count
def add_task(task, priority=0):
'Add a new task or update the priority of an existing task'
if task in entry_finder:
remove_task(task)
count = next(counter)
entry = [priority, count, task]
entry_finder[task] = entry
heappush(pq, entry)
def remove_task(task):
'Mark an existing task as REMOVED. Raise KeyError if not found.'
entry = entry_finder.pop(task)
entry[-1] = REMOVED
def pop_task():
'Remove and return the lowest priority task. Raise KeyError if empty.'
while pq:
priority, count, task = heappop(pq)
if task is not REMOVED:
del entry_finder[task]
return task
raise KeyError('pop from an empty priority queue')
```

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30