A Min-Heap is a Data Structure with the following properties.
- It is a complete Complete Binary Tree.
- The value of the root node must be the smallest among all its descendant nodes and the same thing must be done for its left and right sub-tree also.
The elements of a heap can be mapped into an array using the following rules:
If a node is stored at index k:
- Left child is stored at index 2k + 1 (for 0-based indexing) or 2k (for 1-based indexing).
- Right child is stored at index 2k + 2 (for 0-based indexing) or 2k + 1 (for 1-based indexing).
Example of Min Heap
Tree Representation:
5 13
/ \ / \
10 15 16 31
/ / \ / \
30 41 51 100 41
Array Representation:
For the first tree:
[5, 10, 15, 30]
For the second tree:
[13, 16, 31, 41, 51, 100, 41]
Min Heap Representation as an Array
Since a Min Heap is a Complete Binary Tree, it is commonly represented using an array. In an array representation:
- The root element is stored at
Arr[0]
. - For any i-th node (at
Arr[i]
):- Parent Node →
Arr[(i - 1) / 2]
- Left Child →
Arr[(2 * i) + 1]
- Right Child →
Arr[(2 * i) + 2]
Operations on Min Heap
- getMin(): It returns the root element of Min Heap. Time Complexity of this operation is O(1).
- extractMin(): Removes the minimum element from MinHeap. Time Complexity of this Operation is O(Log n) as this operation needs to maintain the heap property (by calling heapify()) after removing root.
- insert(): Inserting a new key takes O(Log n) time. We add a new key at the end of the tree. If new key is larger than its parent, then we don’t need to do anything. Otherwise, we need to traverse up to fix the violated heap property.
Implementation of Min Heap in Python
Please refer Min-Heap for details.
Python
class MinHeap:
def __init__(self):
self.a = []
"""Insert a new element into the Min Heap."""
def insert(self, val):
self.a.append(val)
i = len(self.a) - 1
while i > 0 and self.a[(i - 1) // 2] > self.a[i]:
self.a[i], self.a[(i - 1) // 2] = self.a[(i - 1) // 2], self.a[i]
i = (i - 1) // 2
"""Delete a specific element from the Min Heap."""
def delete(self, value):
i = -1
for j in range(len(self.a)):
if self.a[j] == value:
i = j
break
if i == -1:
return
self.a[i] = self.a[-1]
self.a.pop()
while True:
left = 2 * i + 1
right = 2 * i + 2
smallest = i
if left < len(self.a) and self.a[left] < self.a[smallest]:
smallest = left
if right < len(self.a) and self.a[right] < self.a[smallest]:
smallest = right
if smallest != i:
self.a[i], self.a[smallest] = self.a[smallest], self.a[i]
i = smallest
else:
break
"""Heapify function to maintain the heap property."""
def minHeapify(self, i, n):
smallest = i
left = 2 * i + 1
right = 2 * i + 2
if left < n and self.a[left] < self.a[smallest]:
smallest = left
if right < n and self.a[right] < self.a[smallest]:
smallest = right
if smallest != i:
self.a[i], self.a[smallest] = self.a[smallest], self.a[i]
self.minHeapify(smallest, n)
"""Search for an element in the Min Heap."""
def search(self, element):
for j in self.a:
if j == element:
return True
return False
def getMin(self):
return self.a[0] if self.a else None
def printHeap(self):
print("Min Heap:", self.a)
# Example Usage
if __name__ == "__main__":
h = MinHeap()
values = [10, 7, 11, 5, 4, 13]
for value in values:
h.insert(value)
h.printHeap()
h.delete(7)
print("Heap after deleting 7:", h.a)
print("Searching for 10 in heap:", "Found" if h.search(10) else "Not Found")
print("Minimum element in heap:", h.getMin())
OutputMin Heap: [4, 5, 11, 10, 7, 13]
Heap after deleting 7: [4, 5, 11, 10, 13]
Searching for 10 in heap: Found
Minimum element in heap: 4
Implementation of Min Heap Using Python’s heapq Library
Python’s heapq module implements a Min Heap by default.
Python
# Python3 program to demonstrate working of heapq
from heapq import heapify, heappush, heappop
# Creating empty heap
heap = []
heapify(heap)
# Adding items to the heap using heappush function
heappush(heap, 10)
heappush(heap, 30)
heappush(heap, 20)
heappush(heap, 400)
# printing the value of minimum element
print("Head value of heap : "+str(heap[0]))
# printing the elements of the heap
print("The heap elements : ")
for i in heap:
print(i, end = ' ')
print("\n")
element = heappop(heap)
# printing the elements of the heap
print("The heap elements : ")
for i in heap:
print(i, end = ' ')
OutputHead value of heap : 10
The heap elements :
10 30 20 400
The heap elements :
20 30 400
Implementation of Min Heap using queue.PriorityQueue
Please refer queue.PriorityQueue for details.
Python
from queue import PriorityQueue
q = PriorityQueue()
# insert into queue
q.put(10)
q.put(20)
q.put(5)
# remove and return
# lowest priority item
print(q.get())
print(q.get())
# check queue size
print('Items in queue :', q.qsize())
# check if queue is empty
print('Is queue empty :', q.empty())
# check if queue is full
print('Is queue full :', q.full())
Output5
10
Items in queue : 1
Is queue empty : False
Is queue full : False
Similar Reads
Python Tutorial | Learn Python Programming Language Python Tutorial â Python is one of the most popular programming languages. Itâs simple to use, packed with features and supported by a wide range of libraries and frameworks. Its clean syntax makes it beginner-friendly.Python is:A high-level language, used in web development, data science, automatio
10 min read
DSA Tutorial - Learn Data Structures and Algorithms DSA (Data Structures and Algorithms) is the study of organizing data efficiently using data structures like arrays, stacks, and trees, paired with step-by-step procedures (or algorithms) to solve problems effectively. Data structures manage how data is stored and accessed, while algorithms focus on
7 min read
Python Interview Questions and Answers Python is the most used language in top companies such as Intel, IBM, NASA, Pixar, Netflix, Facebook, JP Morgan Chase, Spotify and many more because of its simplicity and powerful libraries. To crack their Online Assessment and Interview Rounds as a Python developer, we need to master important Pyth
15+ min read
Quick Sort QuickSort is a sorting algorithm based on the Divide and Conquer that picks an element as a pivot and partitions the given array around the picked pivot by placing the pivot in its correct position in the sorted array. It works on the principle of divide and conquer, breaking down the problem into s
12 min read
Merge Sort - Data Structure and Algorithms Tutorials Merge sort is a popular sorting algorithm known for its efficiency and stability. It follows the divide-and-conquer approach. It works by recursively dividing the input array into two halves, recursively sorting the two halves and finally merging them back together to obtain the sorted array. Merge
14 min read
Bubble Sort Algorithm Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. This algorithm is not suitable for large data sets as its average and worst-case time complexity are quite high.We sort the array using multiple passes. After the fir
8 min read
Data Structures Tutorial Data structures are the fundamental building blocks of computer programming. They define how data is organized, stored, and manipulated within a program. Understanding data structures is very important for developing efficient and effective algorithms. What is Data Structure?A data structure is a st
2 min read
Breadth First Search or BFS for a Graph Given a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Python OOPs Concepts Object Oriented Programming is a fundamental concept in Python, empowering developers to build modular, maintainable, and scalable applications. By understanding the core OOP principles (classes, objects, inheritance, encapsulation, polymorphism, and abstraction), programmers can leverage the full p
11 min read
Binary Search Algorithm - Iterative and Recursive Implementation Binary Search Algorithm is a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N). Binary Search AlgorithmConditions to apply Binary Searc
15 min read