1. heapsort
Heap pila de clasificación Un algoritmo es tal estructura de una de datos diseñado, aproximadamente un árbol binario completo, mientras que con un valor característico de la nodo padre es mayor que el valor de (menor que) el nodo hijo.
Heap dos, el nodo padre es mayor que el nodo hijo que se llama el máximo del montón, el nodo padre es más pequeño que los nodos mínimo niño llamados montón
Aquí está uno de los más grandes del montón
el paso 2. heapsort
El ejemplo máximo del montón, se supone que hay n elementos,
1) La estructura de pila máxima
2) el valor del nodo raíz de los nodos de conmutación n-ésimo
3) ajustado a la corriente montón de almacenamiento dinámico máximo
4) n menos uno, seguido 2) 3) paso, hasta n == 1
3. ¿Cómo construir el más grande del montón
De la naturaleza del almacenamiento dinámico máximo, el valor de cada uno de los padres que el nodo hijo de un valor grande, por lo que desde el ajuste hasta después de la parte inferior de la raíz de ajuste es el más grande. por ejemplo
Suponiendo que el array matriz: 
1) primero imaginar la forma siguiente (árbol binario), ordenados en una matriz o en secuencia,
2) la construcción comenzó máximo del montón
1. El primero encontrar el último nodo padre, ya que la forma de pila máxima la forma anterior, es fácil de obtener un índice final del nodo padre, los elementos anteriores son 8
A continuación, el índice del último nodo padre: I = 8 / 2-1 = 3, y el subíndice del nodo hijo izquierdo del nodo es: 2i + 1, el derecho subíndices de nodo secundario: 2i + 2 Esta es una propiedad importante .
La comparación de los valores de i correspondiente y 2i + 1,2i + 2, y si los dos nodos secundarios es mayor que un nodo padre, entonces el valor de cambio de los nodos padre e hijo, y prestar atención a juez 2i + 1 y 2i + 2 existe o no (es decir, el subíndice no fuera de límites)
Después de que el primer ajuste:
En segundo lugar:
tercera
cuarto
En este caso, prestar atención a la parte posterior de los nodos de conmutación puede dar como resultado no satisface la naturaleza máximo del montón, a continuación, seguir los pasos anteriores, es en realidad un recursivo, espera para la próxima mirada como para entender el código
En quinto lugar, el ajuste se ha completado
Comience con el intercambio
3) de cambio del valor de la ni nodo raíz (i es el número de elementos se ha intercambiado) elementos
4) se ajusta a una pila máximo, esta vez de arriba hacia abajo de ajuste, el ajuste se inicia desde el nodo raíz.
5) Continuar 3), 4) paso, hasta que ni == 1, esta vez el tipo es completa
En combinación con el código de nuevo, es fácil comprender la
Código es el siguiente:
. 1 #include <stdio.h> 2 // valores de canje de los números . 3 void la swap ( int * A, int * B) 4. { 5. Int TEMP * = A; . 6 * = A * B; . 7 * B = TEMP ; 8 } 9 // configurado máxima proceso de pila de 10 void maxHead ( int * ARR, int Inicio, int End) 11. { 12 es int la parentNode = Start; // nodo padre 13 es intla childNode = la parentNode * 2 + 1. ; // nodo hijo izquierdo 14 al mismo tiempo (la childNode <= End) 15 { 16 // . la childNode + 1 es un nodo hijo derecho . 17 SI (el childNode + . 1 <= End && ARR [el childNode + . 1 ]> ARR [el childNode] ) 18 es la childNode ++; // niño grande derecha, derecha toma niño 19 // nodo padre es mayor que un nodo hijo, sin intercambio, retorno directo 20 es SI (ARR [el parentNode]> ARR [el childNode]) 21 es de retorno ; 22 es // lo contrario , el valor de cambio del nodo padre y el niño nodo 23 es el otro 24 { 25 el swap (y ARR [el parentNode], y ARR [el childNode]); 26 es 27 // después de volver de conmutación puede causar nodo 28 // no cumple con los requisitos de la máximo del montón, de modo volver a la configuración del nodo 29 el parentNode = la childNode ; 30 la childNode la parentNode * = 2 + 1. ; 31 es } 32 } 33 es 34 es } 35 void headSort ( int * ARR, int num) 36 { 37 [ // número de elementos de matriz num 38 es int I; 39 // inicial configurada para apilar un máximo 40 para (NUM = I / 2 - 1. ; I> = 0 ; i-- ) 41 es maxHead (ARR, I, nú- 1. ); 42 es 43 es para (num-I = 1. ; I> 0 ; i-- ) 44 es { 45 el swap (y ARR [I], y ARR [ 0 ]); // intercambiar el primer y el segundo elemento i (i desde el elemento trasero primera) 46 está maxHead (ARR, 0 , I- . 1 ); // después del intercambio está configurado para continuar con la operación de la pila máximo 47 } 48 } 49 int main () 50 { 51 int i; 52 int arr [ 8 ] = { 1 , 5 , 0 , 6 , 3 , 9 , 8 , 7 }; 53 headSort (arr, 8 ); // 堆排序 54 para (i = 0 ; i < 8 ; i ++ ) 55 printf ( " % d \ n " , arr [i]); 56 de retorno 0 ; 57 }
HeapSort tiempo medio de complejidad es: O (nlogn)
Hay preguntas, no dude en contactar