El método heapsort, también conocido como ordenación por montículos, utiliza una estructura de datos llamada montículo, específicamente montículos máximos, donde cada nodo padre es mayor que sus nodos hijos. Este método se basa en dos pasos principales: construir un montículo a partir de los datos y eliminar repetidamente la raíz del montículo para obtener los elementos ordenados. La inserción y eliminación de elementos en un montículo requieren operaciones precisas para mantener la estructura balanceada.

1. Unidad VII – Estructura de datos
Ordenamientos internos
Método Heapsort
ordenamiento por montículos
Deini Resendiz Benitez
Martin Pacheco Chavez

2. Método Heapsort
• El método de ordenación heapsort se
conoce también como por ordenación por
montículos, y trabaja con montículos
máximos.
• Es necesario saber que es un montículo, la
inserción y eliminación de los elementos,
para el entendimiento de este método.

3. ¿Qué es un montículo?
• Un montículo se define como: Una
estructura basada en un árbol, donde
cada nodo padre es mayor a sus
nodos hijos y además toda la
estructura esta balanceada.

4. Existen:
• Los montículos máximos tienen la
característica de que cada nodo padre tiene un
valor mayor que el de cualquiera de sus nodos
hijos.
• Los montículos mínimos, el valor del nodo
padre es siempre menor al de sus nodos hijos.

5. Método Heapsort
• Este método es el más eficiente de los métodos de ordenación que
trabajan con estructuras tipo arboles. La idea central de este algoritmo
se basa en dos operaciones:
1. Construir un montículo.
2. Eliminar la raíz del montículo en forma repetida.

6. Árbol binario de búsqueda Montículo máximo
60
46 79
6530 55
79
55 65
6030 46
Gráficamente

7. Árbol binario de búsqueda Montículo mínimo
60
46 79
6530 55
30
46 60
6579 55
Gráficamente

8. No se considera como montículo si los niveles no se encuentran
balanceados
Estructura no
balanceada
79
65
55
60
46
30

9. Para balancearlo habría que reacomodar los elementos.
Estructura
balanceada
79
55 65
6030 46

10. 79
55 65
6030 46
79 > 55 & 65
55 > 30 & 46 65 > 60
Todos los nodos son mayores a sus hijos.
Montículo máximo

11. • Para representar un montículo en un
arreglo se debe considerar lo siguiente.
• Teniendo el nodo padre en la posición K:
– Su hijo izquierdo es 2 * K.
– Su hijo derecho es 2 * K + 1.

12. Montículo máximo representado en
un arreglo
79
55 65
6030 46
79 55 65 30 46 60
1 2 3 4 5 6
Para cualquier nodo K:
Su hijo izquierdo es 2 * K.
Su hijo derecho es 2 * K + 1.
A

13. 79 55 65 30 46 60
1 2 3 4 5 6
Para cualquier nodo K:
Su hijo izquierdo es 2 * K.
Su hijo derecho es 2 * K + 1.
Ejemplo. Si K = 2, entonces:
Su hijo Izquierdo es:
A[2*k] = A[2*2] = A[4]
El hijo izquierdo de A[2] es A[4]
A
Calculo de Hijos
79
55 65
6030 46

14. 79 55 65 30 46 60
1 2 3 4 5 6
Para cualquier nodo no raíz K:
Su padre es K/2.
Si K es impar, se considera K/2 - 0.5
Ejemplo. Si K = 5, entonces:
Su padre es:
A[K/2] = A[5/2-0.5] = A[2]
El padre de A[5] es A[2]
A
Calculo de Padres
79
55 65
6030 46

15. Algoritmo de inserción
1. Se inserta el elemento en la primera posición
disponible.
2. Se verifica si su valor es mayor que el de su padre.
Si se cumple esta condición, entonces se efectúa
el intercambio. Si no, entonces el algoritmo se
detiene y el elemento queda ubicado en su
posición correcta.
*** El paso 2 se aplica de manera recursiva
mientras el elemento tenga un padre.

16. 1. Construcción de un montículo
• Se dan n valores enteros cualquiera:
15 60 08 16 44 27 12 35

17. Inserción de 15 15 60 08 16 44 27 12 35
Considerando que se tiene un
montículo vacío:
1515
raíz
Paso 1:
El numero 15 llega en la primera posición
disponible.
Algoritmo:

18. Inserción de 60 15 60 08 16 44 27 12 35
15 60
15
raíz
60
Paso 1:
El numero 60 llega en la primera posición
disponible.
Algoritmo:

19. Inserción de 60 15 60 08 16 44 27 12 35
15 60
15
raíz
60
Paso 2:
Se verifica si 60 es mayor a su padre, en
este caso 15.
¿60 > 15?
Algoritmo:

20. Inserción de 60 15 60 08 16 44 27 12 35
60 15
60
raíz
15
Paso 2:
Como 60 si es mayor a 15, se efectúa un
intercambio. Después de esto la inserción
finaliza.
Algoritmo:

21. Inserción de 08 15 60 08 16 44 27 12 35
60 15 08
60
raíz
15
Paso 1:
El numero 08 llega en la primera posición
disponible.
Algoritmo:
08

22. Inserción de 08 15 60 08 16 44 27 12 35
60 15 08
60
raíz
15
Paso 2:
Se verifica si 8 es mayor a su padre, en
este caso 60.
Algoritmo:
08
¿8 > 60?

23. Inserción de 08 15 60 08 16 44 27 12 35
60 15 08
60
raíz
15
Paso 2:
Como 8 no es mayor a 60, el algoritmo
finaliza y la inserción finaliza.
Algoritmo:
08

24. Inserción de 16 15 60 08 16 44 27 12 35
60 15 08 16
60
raíz
15
Paso 1:
El numero 16 llega en la primera posición
disponible.
Algoritmo:
08
16

25. Inserción de 16 15 60 08 16 44 27 12 35
60 15 08 16
60
raíz
15
Paso 2:
Se verifica si 16 es mayor a su padre, en
este caso 15.
Algoritmo:
08
16
¿16 > 15?

26. Inserción de 16 15 60 08 16 44 27 12 35
60 16 08 15
60
raíz
16
Paso 2:
Como 16 si es mayor a 15, se efectúa un
intercambio.
Se aplica la recursividad del paso 2.
Algoritmo:
08
15

27. Inserción de 16 15 60 08 16 44 27 12 35
60 16 08 15
60
raíz
16
Paso 2:
Se verifica si 16 es mayor a su padre, en
este caso 60.
Algoritmo:
08
15
¿16 > 60?

28. Inserción de 16 15 60 08 16 44 27 12 35
60 16 08 15
60
raíz
16
Paso 2:
Como 16 no es mayor a 60, el algoritmo
finaliza y la inserción finaliza.
Algoritmo:
08
15

29. Inserción de 44 15 60 08 16 44 27 12 35
60 16 08 15 44
60
raíz
16
Paso 1:
El numero 44 llega en la primera posición
disponible.
Algoritmo:
08
15 44

30. Inserción de 44 15 60 08 16 44 27 12 35
60 16 08 15 44
60
raíz
16
Paso 2:
Se verifica si 44 es mayor a su padre, en
este caso 16.
Algoritmo:
08
15 44 ¿44 > 16?

31. Inserción de 44 15 60 08 16 44 27 12 35
60 44 08 15 16
60
raíz
44
Paso 2:
Como 44 si es mayor a 16, se efectúa un
intercambio.
Se aplica la recursividad del paso 2.
Algoritmo:
08
15 16

32. Inserción de 44 15 60 08 16 44 27 12 35
60 44 08 15 16
60
raíz
44
Paso 2:
Se verifica si 44 es mayor a su padre, en
este caso 60.
Algoritmo:
08
15 16 ¿44 > 60?

33. Inserción de 44 15 60 08 16 44 27 12 35
60 44 08 15 16
60
raíz
44
Paso 2:
Como 44 no es mayor a 60, el algoritmo
finaliza y la inserción finaliza.
Algoritmo:
08
15 16

34. Inserción de 27 15 60 08 16 44 27 12 35
60 44 08 15 16 27
60
raíz
44
Paso 1:
El numero 27 llega en la primera posición
disponible.
Algoritmo:
08
15 16 27

35. Inserción de 27 15 60 08 16 44 27 12 35
60 44 08 15 16 27
60
raíz
44
Paso 2:
Se verifica si 27 es mayor a su padre, en
este caso 8.
Algoritmo:
08
15 16 27
¿27 > 8?

36. Inserción de 27 15 60 08 16 44 27 12 35
60 44 27 15 16 8
60
raíz
44
Paso 2:
Como 27 si es mayor a 8, se efectúa un
intercambio.
Se aplica la recursividad del paso 2.
Algoritmo:
27
15 16 08

37. Inserción de 27 15 60 08 16 44 27 12 35
60 44 27 15 16 8
60
raíz
44
Paso 2:
Se verifica si 27 es mayor a su padre, en
este caso 60.
Algoritmo:
27
15 16 08
¿27 > 60?

38. Inserción de 27 15 60 08 16 44 27 12 35
60 44 27 15 16 8
60
raíz
44
Paso 2:
Como 27 no es mayor a 60, el algoritmo
finaliza y la inserción finaliza.
Algoritmo:
27
15 16 08

39. Inserción de 12 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12
60
raíz
44
Paso 1:
El numero 12 llega en la primera posición
disponible.
Algoritmo:
27
15 16 08 12

40. Inserción de 12 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12
60
raíz
44
Paso 2:
Se verifica si 12 es mayor a su padre, en
este caso 27.
Algoritmo:
27
15 16 08 12
¿12 > 27?

41. Inserción de 12 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12
60
raíz
44
Paso 2:
Como 12 no es mayor a 27, el algoritmo
finaliza y la inserción finaliza.
Algoritmo:
27
15 16 08 12

42. Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12 35
60
raíz
44
Paso 2:
El numero 35 llega en la primera posición
disponible.
Algoritmo:
27
15 16 08 12
35

43. Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 15 16 8 12 35
60
raíz
44
Paso 2:
Se verifica si 35 es mayor a su padre, en
este caso 15.
Algoritmo:
27
15 16 08 12
35 ¿35 > 15?

44. Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 35 16 8 12 15
60
raíz
44
Paso 2:
Como 35 si es mayor a 15, se efectúa un
intercambio.
Se aplica la recursividad del paso 2.
Algoritmo:
27
35 16 08 12
15

45. Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 35 16 8 12 15
60
raíz
44
Paso 2:
Se verifica si 35 es mayor a su padre, en
este caso 44.
Algoritmo:
27
35 16 08 12
15 ¿35 > 44?

46. Inserción de 35 15 60 08 16 44 27 12 35
60 44 27 35 16 8 12 15
60
raíz
44
Paso 2:
Como 35 no es mayor a 44, el algoritmo
finaliza y la inserción finaliza.
Algoritmo:
27
35 16 08 12
15

47. 15 60 08 16 44 27 12 35
De los números:
60 44 27 35 16 8 12 15
Se obtiene el montículo:
60
raíz
44 27
35 16 08 12
15

48. Construcción de Montículos - Métodos necesarios.
//int a[] es el monticulo. int i es el hijo.
public static int padre(int a[], int i){
//Si i es la raíz, no tiene padre, por lo tanto regresa un -1.
if(i == 0)
return -1; //Regresa -1.
else
return (i - 1)/ 2; //Regresa la posición del padre del elemento i.
}
Este método regresa la posición del padre de un elemento en un montículo.
El único elemento que no tiene padre, es el elemento a[0], la cual es la raíz.

49. Construcción de Montículos - Métodos necesarios.
//int a[] es el monticulo. int i es el hijo.
public static int hijoIzq(int a[], int i){
//Si i NO tiene hijo izquierdo, entonces
if(2*i+1 >= a.length)
//Regresa -1
return -1;
//Si no
else
//Regresa la posicion del hijo izquierdo.
return (2 * i + 1);
}
Este método regresa la posición en el arreglo del hijo izquierdo del elemento i.
Retorna un -1 si el elemento no tiene hijo izquierdo.

50. Construcción de Montículos - Métodos necesarios.
//int a[] es el monticulo. int i es el hijo.
public static int hijoDer(int a[], int i){
//Si i NO tiene hijo izquierdo, entonces
if((2*i+1)+1 >= a.length)
//Regresa -1
return -1;
//Si no
else
//Regresa la posicion del hijo izquierdo.
return (2 * i + 1) + 1;
}
Este método regresa la posición en el arreglo del hijo derecho del elemento i.
Retorna un -1 si el elemento no tiene hijo derecho.

51. Construcción de Montículos - Métodos necesarios.
private static int[] hacerMonticulo(int a[]){
int n = a.length;
for (int i = 0; i < n; i++) {
//Si tiene padre, entonces
if(padre(a, i) != -1){
//Se busca al padre de i y se asigna el valor.
int padre = a[padre(a, i)];
//Si el elemento i es mayor que el padre, entonces.
if(a[i] > padre){
//Hacer el intercambio.
int aux = padre;
a[padre(a, i)] = a[i];
a[i] = aux;
//Se realiza de nuevo el metodo de manera recursiva.
hacerMonticulo(a);
}
}
}
return a; //Regresar lo resultante de a.
}

52. Método Heapsort
• Una vez hecha la construcción de un montículo partiendo de un
arreglo, se puede proceder a el paso 2 del método de ordenación.
*** El efecto de ordenación, surge una vez realizando el paso 2. ***
1. Construir un montículo.
2. Eliminar la raíz del montículo en forma repetida.

53. 2. Eliminación de la raíz.
• El proceso para obtener los elementos
ordenados se efectúa eliminando la raíz
del montículo de forma repetida n veces.

54. Algoritmo de eliminación
1. Se remplaza la raíz con el elemento que ocupa la ultima
posición del montículo.
2. Se crea un montículo con los elementos restantes.

55. 60 44 27 35 16 8 12 15
Dado el montículo:
60
raíz
44 27
35 16 08 12
15

56. Eliminación de 60
60
raíz
44
Paso 1:
La raíz se elimina, y es remplazada por el
ultimo elemento
Algoritmo:
27
35 16 08 12
15
60 44 27 35 16 8 12 15

57. Eliminación de 60
15
raíz
44
Paso 1:
60 es remplazado por 15. El elemento
eliminado se coloca en la ultima posición.
Algoritmo:
27
35 16 08 12
15 44 27 35 16 8 12 60

58. Eliminación de 60
Paso 2:
Se crea un montículo con los elementos
restantes
Algoritmo:
15
raíz
44 27
35 16 08 12
15 44 27 35 16 8 12 60

59. Eliminación de 60
44
raíz
25
Paso 2:
Se crea un montículo con los elementos
restantes
Algoritmo:
27
15 16 8 12
44 35 27 15 16 8 12 60

60. Eliminación de 44
44
raíz
25
Paso 1:
La raíz se elimina, y es remplazada por el
ultimo elemento
Algoritmo:
27
15 16 8 12
44 35 27 15 16 8 12 60

61. Eliminación de 44
12
raíz
25
Paso 1:
44 es remplazado por 12. El elemento
eliminado se coloca en la ultima posición.
Algoritmo:
27
15 16 8
12 35 27 15 16 8 44 60

62. Eliminación de 44
12
raíz
25
Paso 2:
Se crea un montículo con los elementos
restantes.
Algoritmo:
27
15 16 8
12 35 27 15 16 8 44 60

63. Eliminación de 44
35
raíz
16
Paso 2:
Se crea un montículo con los elementos
restantes.
Algoritmo:
27
12 15 8
35 16 27 12 15 8 44 60

64. Eliminación de 35
35
raíz
16
Paso 1:
La raíz se elimina, y es remplazada por el
ultimo elemento.
Algoritmo:
27
12 15 8
35 16 27 12 15 8 44 60

65. Eliminación de 35
8
raíz
16
Paso 1:
35 es remplazado por 8. El elemento
eliminado se coloca en la ultima posición.
Algoritmo:
27
12 15
8 16 27 12 15 35 44 60

66. Eliminación de 35
35
raíz
16
Paso 2:
Se crea un montículo con los elementos
restantes.
Algoritmo:
27
12 15
8 16 27 12 15 35 44 60

67. Eliminación de 35
27
raíz
15
Paso 2:
Se crea un montículo con los elementos
restantes.
Algoritmo:
16
8 12
27 15 16 8 12 35 44 60

68. Eliminación de 27
27
raíz
15
Paso 1:
La raíz se elimina, y es remplazada por el
ultimo elemento.
Algoritmo:
16
8 12
27 15 16 8 12 35 44 60

69. Eliminación de 27
12
raíz
15
Paso 1:
27 es remplazado por 12. El elemento
eliminado se coloca en la ultima posición.
Algoritmo:
16
8
12 15 16 8 27 35 44 60

70. Eliminación de 27
12
raíz
15
Paso 2:
Se crea un montículo con los elementos
restantes.
Algoritmo:
16
8
12 15 16 8 27 35 44 60

71. Eliminación de 27
16
raíz
12
Paso 2:
Se crea un montículo con los elementos
restantes.
Algoritmo:
15
8
16 12 15 8 27 35 44 60

72. Eliminación de 16
16
raíz
12
Paso 1:
La raíz se elimina, y es remplazada por el
ultimo elemento.
Algoritmo:
15
8
16 12 15 8 27 35 44 60

73. Eliminación de 16
8
raíz
12
Paso 1:
16 es remplazado por 8. El elemento
eliminado se coloca en la ultima posición.
Algoritmo:
15
8 12 15 16 27 35 44 60

74. Eliminación de 16
8
raíz
12
Paso 2:
Se crea un montículo con los elementos
restantes.
Algoritmo:
15
8 12 15 16 27 35 44 60

75. Eliminación de 16
15
raíz
8
Paso 2:
Se crea un montículo con los elementos
restantes.
Algoritmo:
12
15 8 12 16 27 35 44 60

76. Eliminación de 15
15
raíz
8
Paso 1:
La raíz se elimina, y es remplazada por el
ultimo elemento.
Algoritmo:
12
15 8 12 16 27 35 44 60

77. Eliminación de 15
12
raíz
8
Paso 1:
15 es remplazado por 12. El elemento
eliminado se coloca en la ultima posición.
Algoritmo:
12 8 15 16 27 35 44 60

78. Eliminación de 15
12
raíz
8
Paso 2:
Se crea un montículo con los elementos
restantes..
Algoritmo:
12 8 15 16 27 35 44 60

79. Eliminación de 12
12
raíz
8
Paso 1:
La raíz se elimina, y es remplazada por el
ultimo elemento.
Algoritmo:
12 8 15 16 27 35 44 60

80. Eliminación de 12
8
raíz
Paso 1:
12 es remplazado por 8. El elemento
eliminado se coloca en la ultima posición.
Algoritmo:
8 12 15 16 27 35 44 60

81. Eliminación de 8
8
raíz
Paso 1:
Al quedar un solo elemento en el montículo,
se finaliza el algoritmo.
Algoritmo:
8 12 15 16 27 35 44 60

82. Al finalizar obtenemos el arreglo
8 12 15 16 27 35 44 60
Arreglo ordenado ascendentemente.

83. Método Heapsort
1. Construir un montículo.
2. Eliminar la raíz del montículo en forma repetida.

84. Eliminación de raíz - Métodos necesarios.
//Elimina la raíz del montículo a[], donde el tamaño es n.
public static int[] eliminarRaiz(int a[], int n){
// n = tamaño del montículo
int aux;
aux = a[n-1];
a[n-1] = a[0];
a[0] = aux;
return a;
}
Este método regresa un arreglo, donde la raíz se ha intercambiado por el ultimo
elemento del arreglo

85. Método heapsort
public static int[] heapsort(int a[]){
int n = a.length;
//Paso 1. Hacer montículo.
int monticulo[] = hacerMonticulo(a, n);
//Paso 2. Eliminar la raíz repetidas veces.
for (int i = 0; i < monticulo.length; i++) {
monticulo = eliminarRaiz(monticulo, n-i);
monticulo = hacerMonticulo(monticulo, n-i-1);
}
return monticulo;
}

86. 8 12 15 16 27 35 44 60
15 60 8 16 44 27 12 35
60 44 27 35 16 8 12 15
Arreglo inicial
Paso 1: Hacer
Montículo
Paso 2: Repetir:
Eliminar la raíz y
hacer un moitculo.
Método heapsort

87. • Gracias.

88. Fuentes:
• Estructura de Datos . Tercera Edición – Osvaldo Cairó y Silvia Guardati.
McGrawHill Editorial.
• Estructuras de Datos en Java - Luis Joyanes Aguilar. McGrawHill
Editorial.