Heapsort es un algoritmo de ordenación que utiliza una estructura de árbol binario llamada montículo para organizar elementos mediante comparación. Su complejidad es O(n log n) en todos los casos, y el proceso de ordenación implica construir el montículo, intercambiar elementos y restaurar la estructura del montículo repetidamente. El documento también incluye un código en Java que implementa el algoritmo de ordenación por montículos.

1. HEAP SORT
EDWIN LOBO HERNANDEZ

2. ¿Qué es HeapSort?
Es un algoritmo de ordenación basado en la
comparación de los elementos a ordenar.
Ordenación por montículos

3. ¿Qué es HeapSort?
• El Heapsort esta basado en el uso de un tipo especial de
un árbol binario llamado montículo.
Heap

4. Heap
(montículo)
• El acceso a los elementos del Heap en un arreglo, se hace
a través de algunas operaciones aritméticas básicas:
• Hijo izquierdo = 2 * i
• Hijo derecho = 2 * i
• Padre = i / 2
8 5 6 7 4 2
ii i i i i

5. ¿Cómo funciona
HeapSort?
1.Se construye el
montículo inicial a partir
del arreglo original.
2. Se intercambia la
raíz con el ultimo
elemento del
montículo.
3. El ultimo elemento
queda ordenado.
4. El ultimo
elemento se saca
del montículo, no
del arreglo.
5. Se restaura el
montículo haciendo que
el primer elemento baje
a la posición que le
corresponde, si sus hijos
son menores.
6. La raíz vuelve a ser el
mayor del montículo.
7. Se repite el paso
2 hasta que quede
un solo elemento
en el montículo

6. Complejidad de HeapSort
La complejidad del algoritmo de ordenación por
montículos es
O(n log n).
• Su complejidad en todos los casos es la
misma.

7. // Ordenación por montículos – HeapSort
public static void ordenacionMonticulos ( int [] v ) {
final int N = v.length;
for ( int nodo = N/2; nodo >= 0; nodo -- ){
hacerMonticulo(v, nodo, N-1); }
for( int nodo = N-1; nodo >= 0; nodo -- ) {
int tmp = v [0];
v[0] = v [nodo];
v [nodo] = tmp;
hacerMonticulo(v, 0, nodo-1);
}
}
Código en java

8. Código en java
public static void hacerMonticulo(int[] v, int nodo, int fin) {
int izq = 2 * nodo + 1;
int der = izq + 1;
int may;
if ( izq > fin ) return;
if ( der > fin ) may = izq;
else may = v [ izq ] > v [ der ] ? izq : der;
if ( v [ nodo ] < v [ may ] ) {
int tmp = v [ nodo ];
v [ nodo ] = v [ may ];
v [ may ] = tmp;
hacerMonticulo(v, may, fin);
}
}

9. REFERENCIAS
• http://jorgep.blogspot.com/2010/09/ordenacion-por-monticulos-heap-sort.html
• http://alguienenlafisi.blogspot.com/2011/10/ordenamiento-por-monticulos-heapsort.html
• http://www.mat.uson.mx/omrodriguez/algoritmos/HeapSort/index.html
• http://metodopormonticulos.blogspot.com/2010/11/heapsort.html

10. ¿PREGUNTAS?

11. GRACIAS