Introducción al uso de la biblioteca heapq de Python

Introducción al uso de la biblioteca heapq de Python

1. Introducción a la biblioteca heapq

La biblioteca heapq es una de las bibliotecas estándar de Python. Proporciona métodos para construir pequeños montones superiores y algunas operaciones básicas en pequeños montones superiores (como entrada de montón, salida de montón, etc.), que se pueden utilizar para implementar algoritmos de clasificación de montón.

El montón es una estructura de datos básica. La estructura del montón es un árbol binario completo y satisface la naturaleza de la acumulación: el valor de cada nodo (excepto los nodos hoja) es mayor o igual a (o menor o igual a) su nodos secundarios.

La estructura del montón se divide en un montón superior grande y un montón superior pequeño. El montón superior pequeño se usa en heapq:

1. Gran pila superior: el valor de cada nodo (excepto los nodos hoja) es mayor o igual que el valor de sus nodos secundarios, y el valor del nodo raíz es el mayor de todos los nodos.

2. Montón superior pequeño: el valor de cada nodo (excepto los nodos hoja) es menor o igual que el valor de sus nodos secundarios, y el valor del nodo raíz es el más pequeño de todos los nodos.

En la biblioteca heapq, el tipo de datos utilizado por heapq es la lista de tipos de datos básicos de Python. Para satisfacer la naturaleza de la acumulación, en esta lista, el valor del índice k debe ser menor o igual que el valor del índice 2 * k + 1 e índice 2 * k El valor de +2 (en un árbol binario completo, los datos se insertan primero en amplitud, y los índices de nodo hijo del nodo con índice k son 2 * k + 1 y 2 * k + 2 respectivamente) . También se introduce en el código fuente de la biblioteca heapq, puede leer el código fuente de heapq, no hay mucho código.

Use Python para lograr la clasificación del montón; puede consultar: https://blog.csdn.net/weixin_43790276/article/details/104033696

Las características del árbol binario completo se pueden consultar en: https://blog.csdn.net/weixin_43790276/article/details/104737870

En segundo lugar, use heapq para crear un montón

# 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 de la operación:

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]

Hay dos formas de crear un montón en heapq.

heappush (montón, num), primero cree un montón vacío y luego agregue datos al montón uno por uno. Después de agregar cada dato, el montón satisface las características del montón superior pequeño.

heapify (matriz), ajusta directamente la lista de datos en un pequeño montón superior (consulte el artículo anterior sobre clasificación de montones para conocer el principio de ajuste, la biblioteca heapq se ha implementado).

Los resultados de los dos métodos serán diferentes. Por ejemplo, en el código anterior, la estructura del montón obtenida usando heappush (heap, num) es la siguiente.

La estructura del montón obtenida usando heapify (matriz) es la siguiente.

Sin embargo, estos dos resultados cumplen las características del montón superior pequeño y no afectan el uso del montón (el montón solo obtendrá datos de la parte superior del montón y la estructura se reajustará después de que se recuperen los datos) .

Tres, use heapq para lograr la ordenación del montón

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 de la operación:

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

Primero agregue los datos en la lista para ordenarlos al montón, construya un pequeño montón superior e imprima los primeros datos para confirmar que es el valor mínimo. Luego, saque los valores en la parte superior del montón uno por uno y agréguelos a una nueva lista hasta que se agoten los datos del montón y la nueva lista sea la lista ordenada.

Heappop (montón), los datos en la parte superior del montón están fuera del montón y los datos restantes en el montón se construyen en un nuevo montón superior pequeño.

Cuatro, obtenga el valor mínimo o máximo en el montón

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 de la operación:

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

nlargest (num, heap), toma num datos del montón, comienza con los datos más grandes y devuelve el resultado como una lista (incluso si solo se toma un dato). Si num es mayor o igual que el número de datos en el montón, entonces todos los datos del montón se tomarán de mayor a menor, no se informará ningún error, lo que equivale a una ordenación descendente.

nsmallest (num, heap), elimina el número de datos del montón, comienza con los datos más pequeños y devuelve el resultado como una lista.

Estos dos métodos se pueden usar en el montón y también se pueden usar directamente en la lista, la función es la misma.

Cinco, use heapq para fusionar dos 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 de la operación:

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

fusionar (lista1, lista2), fusionar dos listas ordenadas en una nueva lista ordenada y el resultado devuelto es un iterador. Este método se puede utilizar para combinar y ordenar.

Seis, el método de reemplazar datos con 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 de la operación:

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), primero agregue num al montón y luego saque los datos superiores del montón.

heapreplace (heap, num), primero elimine los datos superiores del montón y luego agregue num al montón.

Los dos métodos entran y salen del montón, pero el orden es diferente y se pueden usar para reemplazar los datos en el montón. La diferencia específica se puede ver en el ejemplo de código.