Este documento explica el algoritmo de ordenación heap sort. Heap sort utiliza una estructura de datos llamada montículo que mantiene el mayor elemento en la raíz. Primero inserta todos los elementos en un montículo, luego extrae el elemento de la raíz y lo coloca en su posición ordenada, reorganizando el montículo, hasta que todos los elementos estén ordenados. Ventajas incluyen un buen rendimiento promedio y no requiere memoria adicional. Desventajas son que no es estable y es más complejo que otros algoritmos. El document

1. República Bolivariana de Venezuela
Ministerio del Poder Popular para la Defensa
UNEFA – Núcleo Mérida
Integrantes:
Ana Karina Carrillo Camacho
Anthony Manuel Duque Pérez
Katherine Dayan Asuaje Pirela
Miguel Eduardo Villamizar Rosario

2. ¿Qué es heap sort?
Es un algoritmo de ordenación basado en comparaciones de elementos que utiliza un
heap para ordenarlos.
También se puede decir que es un algoritmo de ordenación por selección basado en la
construcción de un árbol parcialmente ordenado.
El algoritmo Heap Sort utiliza una estructura llamada "montículo" que no es otra cosa
más que un árbol binario donde cada nodo padre siempre tiene un valor mayor que el
de todos sus nodos hijos. Además de ello un montículo debe ser un árbol binario
completo.
El algoritmo consiste en insertar todos los elementos del vector en un montículo y
aprovechar que de esta forma siempre tendremos el mayor elemento en la raíz. Luego
para obtener los elementos ordenados de mayor a menor, solo debemos tomar el valor
de la raíz, eliminar la raíz y reordenar el montículo cada vez hasta agotar sus nodos.

14. Ventajas
• La principal ventaja es que este método funciona más efectivamente con datos
desordenados.
• Su desempeño es en promedio tan bueno como el quicksoft y se comporta mejor que
este último en los peores de los casos.
• No utiliza memoria adicional.
Desventajas
• No es estable, debido a que se comporta de manera ineficaz con datos del mismo
valor.
• Método más complejo

15. Codigo de heap sort:
#include <stdio.h>
/*
Inserta un elemento en el monticulo.
v Vector de elementos (monticulo)
n Numero de elementos en el vector
x Nuevo elemento
*/
void heap_insert(int *v, int n, int x) {
// insertamos x después del último elemento
v[n] = x;
// Mientras x sea mayor que su padre...
while(v[(n-1)/2] < v[n]) {
// Intercambiamos x con su padre
int aux = v[(n-1)/2];
v[(n-1)/2] = v[n];
v[n] = aux;
// Actualizamos la posición de x
n = (n-1)/2;
// y volvemos a evaluar con su nuevo padre
}
}
/*
Elimina la raiz del monticulo y devuelve su valor
v Vector de elementos (monticulo)
n Numero de elementos en el vector

16. int heap_remove(int *v, int n) {
// obtenemos el valor de la raiz
int x = v[0];
// movemos a la raiz el ultimo elemento del monticulo
// y reducimos el numero de elementos en 1 (--n)
v[0] = v[--n];
// indice para al elemento movido
int i=0;
// indice para el primer hijo del elemento movido
int h=1;
// mientras aun haya hijos
while(h < n) {
// validamos si hay un segundo hijo
// y si el valor del segundo hijo es mayor que el del primero
if(h+1<n && v[h+1]>v[h]) {
// en ese caso el hijo a tener en cuenta sera el segundo
h++;
}
// nos quedamos con el indice del hijo de mayor valor en "h"
// si el valor del hijo "h" es mayor que el padre "i"
if(v[i] < v[h]) {
// intercambiamos sus valores
int aux = v[i];
v[i] = v[h];
v[h] = aux;
// actualizamos el indice del elemento movido
i = h;
// hallamos el indice de su nuevo primer hijo
h = 2*i+1;
}

17. else {
// terminamos el bucle
h = n;
}
}
// devolvemos el valor de la raiz
return x;
}
/*
Ordena un vector usando un monticulo.
v Vector a ordenar
n Numero de elementos del vector
*/
void heap_sort(int *v, int n) {
// declara un monticulo del tamaño del vector
int *w = new int[n];
// inserta en el monticulo todos los elementos del vector
for(int i=0; i<n; i++) {
heap_insert(w,i,v[i]);
}
// retira cada vez la raiz del monticulo e inserta su valor
// en el vector desde la ultima posicion hacia la primera
for(int i=n; i>0; i--) {
v[i-1] = heap_remove(w,i);
}
}
/*
Programa principal
(Ejemplo de HeapSort)

18. int main() {
int *v, n;
// pide el numero de elementos del vector
printf("n = ");
scanf("%d",&n);
// crea el vector de forma dinamica
v = new int[n];
// pide los elementos del vector
for(int i=0; i<n; i++) {
printf("v[%d] = ",i);
scanf("%d",&v[i]);
}
printf("Heap Sort...n");
// ordena el vector usando HeapSort
heap_sort(v,n);
// muestra el vector ordenado
for(int i=0; i<n; i++) {
printf("v[%d] = %dn",i,v[i]);
}
// fin del programa
return 0;
}