Cómo implementar la clasificación del montón en Python (ejemplo de código)
Clasificación de montón
La clasificación de montón se refiere a un algoritmo de clasificación diseñado para utilizar la estructura de datos de un montón. Un montón es una estructura que se aproxima a un árbol binario completo y satisface las propiedades de un montón: es decir, el valor clave o índice de un nodo hijo siempre es menor (o mayor que) el valor clave o índice de su nodo padre ( pero no hay garantía de que todos los subárboles izquierdos sean más pequeños que el subárbol derecho y viceversa). Se puede decir que la clasificación por montón es una clasificación por selección que utiliza el concepto de montón para ordenar. Hay dos métodos:
Montón superior: el valor de cada nodo es mayor o igual que el valor de su nodo secundario, que se utiliza para la clasificación ascendente en el algoritmo de clasificación del montón
Montón de montón superior pequeño: el valor de cada nodo es menor o igual que el valor de su nodo secundario y se utiliza para la clasificación descendente en el algoritmo de clasificación de montón;
La complejidad temporal promedio de la clasificación de montón es Ο(nlogn).
Pasos del algoritmo
1. Crear montón H[0?n-1] (**Regule los nodos secundarios de los nodos que no son hoja para construir un montón**) p>
2, intercambia la cabeza (valor máximo) del montón y la cola del montón;
3, reduce el tamaño del montón en 1 y llama a shift_down(0), el propósito es ajustar los datos en la parte superior de la nueva matriz a la posición correspondiente
4, repita el paso 2 hasta que el tamaño del montón sea 1.
El código Python implementa def buildMaxHeap(arr):
importar matemáticas
para i in range(math.floor(len(arr)/2), - 1, -1): #Construye el montón de abajo hacia arriba, así que usa -1
heapify(arr, i)
def heapify(arr, i):
izquierda = 2*i 1
derecha = 2*i 2
mayor = i
si izquierda lt y arr[izquierda] gt ; arr[más grande]:
más grande = izquierda
si derecha lt; arrLen y arr[derecha] gt; correcto
si es más grande! = i:
swap(arr, i, mayor)
heapify(arr, mayor)
def swap(arr, i, j): p> p>
arr[i], arr[j] = arr[j], arr[i]
def heapSort(arr):
arrLen global p>
arrLen = len(arr)
buildMaxHeap(arr)
para i en rango(len(arr)-1, 0, -1):
swap(arr, 0, i)
arrLen -=1 # Inicia el valor máximo buscado cada vez
heapify(arr, 0)
regresar llegada