Um Min-Heap é uma árvore binária completa em que o valor em cada nó interno é menor ou igual aos valores nos filhos desse nó. 
Mapear os elementos de um heap em um array é trivial: se um nó é armazenado no índice k, então seu filho esquerdo é armazenado no índice 2k + 1 e seu filho direito no índice 2k + 2 .

Exemplo de pilha mínima:  

            5 13
         / \ / \
       10 15 16 31
      / / \ / \
    30 41 51 100 41

Como Min Heap é representado?  
A Min Heap é uma árvore binária completa. Um heap Min normalmente é representado como uma matriz. O elemento raiz estará em Arr [0] . Para qualquer iº nó, ou seja, Arr [i] :

• Arr [(i -1) / 2] retorna seu nó pai.
• Arr [(2 * i) + 1] retorna seu nó filho esquerdo.
• Arr [(2 * i) + 2] retorna seu nó filho direito.

Operações em Min Heap: 

1. getMin() : retorna o elemento raiz de Min Heap. A complexidade de tempo desta operação é O (1) .
2. extractMin() : remove o elemento mínimo de MinHeap. A complexidade de tempo dessa operação é O (Log n), pois essa operação precisa manter a propriedade heap (chamando heapify()) após a remoção de root.
3. insert() : Inserir uma nova chave leva tempo O (Log n) . Adicionamos uma nova chave no final da árvore. Se a nova chave for maior do que seu pai, não precisamos fazer nada. Caso contrário, precisamos percorrer para corrigir a propriedade de heap violada.

Abaixo está a implementação de Min Heap em Python - 

 
import sys
 
class MinHeap:
 
    def __init__(self, maxsize):
        self.maxsize = maxsize
        self.size = 0
        self.Heap = [0]*(self.maxsize + 1)
        self.Heap[0] = -1 * sys.maxsize
        self.FRONT = 1
 
    
    
    
    def parent(self, pos):
        return pos//2
 
    
    
    
    def leftChild(self, pos):
        return 2 * pos
 
    
    
    
    def rightChild(self, pos):
        return (2 * pos) + 1
 
    
    
    def isLeaf(self, pos):
        if pos >= (self.size//2) and pos <= self.size:
            return True
        return False
 
    
    def swap(self, fpos, spos):
        self.Heap[fpos], self.Heap[spos] = self.Heap[spos], self.Heap[fpos]
 
    
    def minHeapify(self, pos):
 
      
        if not self.isLeaf(pos):
            if (self.Heap[pos] > self.Heap[self.leftChild(pos)] or
               self.Heap[pos] > self.Heap[self.rightChild(pos)]):
 
                            if self.Heap[self.leftChild(pos)] < self.Heap[self.rightChild(pos)]:
                    self.swap(pos, self.leftChild(pos))
                    self.minHeapify(self.leftChild(pos))
 
                            else:
                    self.swap(pos, self.rightChild(pos))
                    self.minHeapify(self.rightChild(pos))
 
    
    def insert(self, element):
        if self.size >= self.maxsize :
            return
        self.size+= 1
        self.Heap[self.size] = element
 
        current = self.size
 
        while self.Heap[current] < self.Heap[self.parent(current)]:
            self.swap(current, self.parent(current))
            current = self.parent(current)
 
    
    def Print(self):
        for i in range(1, (self.size//2)+1):
            print(" PARENT : "+ str(self.Heap[i])+" LEFT CHILD : "+
                                str(self.Heap[2 * i])+" RIGHT CHILD : "+
                                str(self.Heap[2 * i + 1]))
 
    
    
    def minHeap(self):
 
        for pos in range(self.size//2, 0, -1):
            self.minHeapify(pos)
 
    
    
    def remove(self):
 
        popped = self.Heap[self.FRONT]
        self.Heap[self.FRONT] = self.Heap[self.size]
        self.size-= 1
        self.minHeapify(self.FRONT)
        return popped
 
if __name__ == "__main__":
     
    print('The minHeap is ')
    minHeap = MinHeap(15)
    minHeap.insert(5)
    minHeap.insert(3)
    minHeap.insert(17)
    minHeap.insert(10)
    minHeap.insert(84)
    minHeap.insert(19)
    minHeap.insert(6)
    minHeap.insert(22)
    minHeap.insert(9)
    minHeap.minHeap()
 
    minHeap.Print()
    print("The Min val is " + str(minHeap.remove()))

Resultado : 

The Min Heap é
 PAIS: 3 FILHOS ESQUERDOS: 5 FILHOS DIREITOS: 6
 PAI: 5 FILHO ESQUERDO: 9 FILHO DIREITO: 84
 PAI: 6 FILHO ESQUERDO: 19 FILHO DIREITO: 17
 PAI: 9 FILHO ESQUERDO: 22 FILHO DIREITO: 10
O valor mínimo é 3

Usando funções de biblioteca:

Usamos a classe heapq para implementar Heaps em Python. Por padrão, Min Heap é implementado por esta classe.  

 
from heapq import heapify, heappush, heappop
 
heap = []
heapify(heap)
 
heappush(heap, 10)
heappush(heap, 30)
heappush(heap, 20)
heappush(heap, 400)
 
print("Head value of heap : "+str(heap[0]))
 
print("The heap elements : ")
for i in heap:
    print(i, end = ' ')
print("\n")
 
element = heappop(heap)
 
print("The heap elements : ")
for i in heap:
    print(i, end = ' ')

Resultado :  

Valor principal da pilha: 10
Os elementos de heap:
10 30 20 400
Os elementos de heap:
20 30 400