El documento describe el algoritmo de ordenamiento HeapSort. HeapSort funciona construyendo primero un montículo máximo (árbol binario casi completo) del arreglo y luego extrae elementos uno a uno del montículo para colocarlos al final del arreglo ordenado. El costo de tiempo de HeapSort es O(n log n) ya que la construcción del montículo toma O(n) y la extracción y ordenamiento toma O(log n) por cada uno de los n elementos. El documento también incluye ejemplos de código C++ que implementan HeapSort.

1. INTEGRANTES:
Daniela Fernández C.I.: 24.224.414
Jesús Peña C.I.: 23.722.335
Juan Rosas C.I.: 25.916.407
José González C.I.: 25.438.663
HeapSort
REPÚBLICA BOLIVARIANA DE VENZUELA
MINISTERIO DEL PODER POPULAR PARA LA DEFENSA
UNIVERSIDAD NACIONAL EXPERIMENTAL DE LA FUERZA ARMADA
U.N.E.F.A
MÉRIDA – SEDE PRINCIPAL
INGENIERÍA DE SISTEMAS
LENGUAJE DE PROGRAMACIÓN II

2. Heap Sort
Es un árbol binario de altura mínima, en que
los nodos del nivel más bajo están más a la
izquierda posible
La información es almacenada de manera que
al recorrer un camino desde la raíz hacia las
hojas, los datos se encuentran en orden
descendente.

3. Si se presenta este arreglo resultante como un
árbol se observa que cada elemento es el padre de
los otros elementos
puesto que es una estructura con un grupo el cual
En la segunda parte del procedimiento se realiza
el proceso de ordenamiento en la cual se recorre el
árbol de tal forma que el resultado es una lista
ordenada de elementos.
z[i], z[i+1]
J <= i/2

4. Algoritmos de selección del
HeapSort
El vector debe tener estructura de montículo,
es decir un árbol en el que los hijos de cada
nodo son siempre menores que el padre
De esta forma no se tiene que recorrer toda
la zona desordenada para encontrar el
elemento máximo, ya que en este caso la
ordenación se realiza en sentido inverso.

5. La estructura es un montículo que facilita
esta búsqueda y la hace del orden
Por lo tanto el costo final será log(n)para cada
elemento que se quiera colocar en la zona
ordenada es decir
log(n)
O(n) = n log(n)

6. EJEMPLOS

14. #include <iostream>
using namespace std;
const int N=100; //tamaño del monticulo
int HEAP[N];
int n=0; //puntero del montón
void sort(){
int i, subCor, aux;
cout << "Ordenado Ascendente:";
while(--n>=0){//montón está disminuyendo
cout << HEAP[0]<<",";//raíz del montón
HEAP[0]= HEAP[n];
i=0; //índice de la raíz
subCor=i*2+1; //nodo subordinado
if(HEAP[subCor+1]<HEAP[subCor])
subCor++;
while((HEAP[subCor]<HEAP[i]) && (subCor<=n)){
aux = HEAP[subCor];
HEAP[subCor] = HEAP[i];
HEAP[i] = aux;
i= subCor;
subCor =i*2+1;
if(HEAP[subCor+1]<HEAP[subCor])
subCor++;
}//while
}//while
};//sort

15. int main(){
int numero, i, j, aux;
do{
cout << "ingrese una elemento numerico (0 para salir) " ;
cin >> numero;
if(numero == 0)
break;
HEAP[n++]=numero ;
i= n-1 ;
j=(i-1)/2;
while(HEAP[j]>HEAP[i]){ //Edificio del montón
aux=HEAP[j ];
HEAP[j]= HEAP[i];
HEAP[i]= aux;
i=j;
j = (i-1)/2;
}//while
}while(numero!=0); //do while
sort();//imprimir el montos
}