Introdução ao uso da biblioteca heapq do Python

Introdução ao uso da biblioteca heapq do Python

1. Introdução à biblioteca heapq

A biblioteca heapq é uma das bibliotecas padrão do Python. Ela fornece métodos para construir pequenos heaps superiores e algumas operações básicas em pequenos heaps superiores (como entrada de heap, saída de heap etc.), que podem ser usados ​​para implementar algoritmos de classificação de heap.

O heap é uma estrutura de dados básica. A estrutura do heap é uma árvore binária completa e satisfaz a natureza da acumulação: o valor de cada nó (exceto nós folha) é maior ou igual a (ou menor ou igual a) seu nós filhos.

A estrutura do heap é dividida em um heap superior grande e um heap superior pequeno. O heap superior pequeno é usado em heapq:

1. Pilha superior: O valor de cada nó (exceto nós folha) é maior ou igual ao valor de seus nós filhos, e o valor do nó raiz é o maior de todos os nós.

2. Pilha superior pequena: O valor de cada nó (exceto nós folha) é menor ou igual ao valor de seus nós filhos, e o valor do nó raiz é o menor de todos os nós.

Na biblioteca heapq, o tipo de dados usado por heapq é a lista de tipos de dados básicos do Python. Para satisfazer a natureza da acumulação, nesta lista, o valor do índice k deve ser menor ou igual ao valor do índice 2 * k + 1 e índice 2 * k O valor de +2 (em uma árvore binária completa, os dados são inseridos primeiro em largura, e os índices do nó filho do nó com índice k são 2 * k + 1 e 2 * k + 2, respectivamente) . Também é introduzido no código-fonte da biblioteca heapq, você pode ler o código-fonte do heapq, não há muito código.

Use Python para obter classificação de heap. Pode consultar: https://blog.csdn.net/weixin_43790276/article/details/104033696

As características da árvore binária completa podem ser consultadas em: https://blog.csdn.net/weixin_43790276/article/details/104737870

Em segundo lugar, use heapq para criar um heap

# coding=utf-8
import heapq


array = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
heap = []
for num in array:
    heapq.heappush(heap, num)
print("array:", array)
print("heap: ", heap)

heapq.heapify(array)
print("array:", array)

resultado da operação:

array: [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
heap:  [5, 7, 21, 15, 10, 24, 27, 45, 17, 30, 36, 50]
array: [5, 7, 21, 10, 17, 24, 27, 45, 15, 30, 36, 50]

Existem duas maneiras de criar um heap no heapq.

heappush (heap, num), primeiro crie um heap vazio e, em seguida, adicione dados ao heap um por um. Depois que cada dado é adicionado, o heap satisfaz as características do pequeno heap superior.

heapify (array), ajuste diretamente a lista de dados em um pequeno heap superior (consulte o artigo sobre classificação de heap acima para o princípio de ajuste, a biblioteca heapq foi implementada).

Os resultados dos dois métodos serão diferentes.Por exemplo, no código acima, a estrutura de heap obtida usando heappush (heap, num) é a seguinte.

A estrutura de heap obtida usando heapify (array) é a seguinte.

No entanto, esses dois resultados atendem às características do heap superior pequeno e não afetam o uso do heap (o heap só buscará dados do topo do heap e a estrutura será reajustada após os dados serem buscados) .

Três, use heapq para obter classificação de heap

array = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
heap = []
for num in array:
    heapq.heappush(heap, num)
print(heap[0])
# print(heapq.heappop(heap))
heap_sort = [heapq.heappop(heap) for _ in range(len(heap))]
print("heap sort result: ", heap_sort)

resultado da operação:

5
heap sort result:  [5, 7, 10, 15, 17, 21, 24, 27, 30, 36, 45, 50]

Primeiro, adicione os dados da lista a serem classificados no heap, construa um pequeno heap superior e imprima os primeiros dados para confirmar que é o valor mínimo. Em seguida, retire os valores no topo da pilha, um por um, e adicione-os a uma nova lista até que os dados da pilha se esgotem e a nova lista seja a lista classificada.

Heappop (heap), os dados no topo do heap estão fora do heap e os dados restantes no heap são construídos em um novo pequeno heap superior.

Quatro, obtenha o valor mínimo ou máximo no heap

array = [10, 17, 50, 7, 30, 24, 27, 45, 15, 5, 36, 21]
heapq.heapify(array)
print(heapq.nlargest(2, array))
print(heapq.nsmallest(3, array))

resultado da operação:

[50, 45]
[5, 7, 10]

nlargest (num, heap), obtém dados num do heap, começa com os maiores dados e retorna o resultado como uma lista (mesmo se apenas um dado for obtido). Se num for maior ou igual ao número de dados no heap, todos os dados no heap serão retirados do maior para o menor, nenhum erro será relatado, o que é equivalente a uma classificação decrescente.

nsmallest (num, heap), remova os dados num do heap, comece com os menores dados e retorne o resultado como uma lista.

Esses dois métodos podem ser usados ​​no heap e também podem ser usados ​​diretamente na lista, a função é a mesma.

Cinco, use heapq para mesclar duas listas ordenadas

array_a = [10, 7, 15, 8]
array_b = [17, 3, 8, 20, 13]
array_merge = heapq.merge(sorted(array_a), sorted(array_b))
print("merge result:", list(array_merge))

resultado da operação:

merge result: [3, 7, 8, 8, 10, 13, 15, 17, 20]

mesclar (lista1, lista2), mesclar duas listas ordenadas em uma nova lista ordenada e o resultado de retorno é um iterador. Este método pode ser usado para mesclar e classificar.

Seis, o método de substituição de dados por heapq

array_c = [10, 7, 15, 8]
heapq.heapify(array_c)
print("before:", array_c)
# 先push再pop
item = heapq.heappushpop(array_c, 5)
print("after: ", array_c)
print(item)

array_d = [10, 7, 15, 8]
heapq.heapify(array_d)
print("before:", array_d)
# 先pop再push
item = heapq.heapreplace(array_d, 5)
print("after: ", array_d)
print(item)

resultado da operação:

before: [7, 8, 15, 10]
after:  [7, 8, 15, 10]
5
before: [7, 8, 15, 10]
after:  [5, 8, 15, 10]
7

heappushpop (heap, num), primeiro adicione num ao heap e, em seguida, retire os dados principais do heap.

heapreplace (heap, num), primeiro remova os dados principais do heap e, em seguida, adicione num ao heap.

Os dois métodos entram e saem do heap, mas a ordem é diferente e podem ser usados ​​para substituir os dados no heap. A diferença específica pode ser vista no exemplo de código.