ORDENACION MEDIANTE

HEAPSORT
UNIVERSIDAD NACIONAL DE TRUJILLO
INFORMATICA
TRUJILLO – PERU
ING. JUAN ORLANDO SALAZAR CAMPOS

Cadenillas Villacorta Castro Silva Bengi Cheffer Montalvo Córdova Lázaro Sandoval Verjel Yan
Fiorella 474989 Miguel Elicia 478336
222346 Trujillo-Perú 200300 Trujillo-Perú
Trujillo-Perú Trujillo-Peru theyasav@gmail.co
Trujillo-Perú ben_09_14@hotmail
elyo0_cor@hotmail. m
fiore_12_23@hotmail.c .com com
oom

RESUMEN
En este documento se estudiara el algoritmo de ordenación Heapsort los
cuales son muy usados y básicos en la enseñanza de algoritmia. Por su fácil
codificación y entendimiento explicaremos detalladamente cada uno de los
dos algoritmos de ordenación, con sus respectivas características,,
funcionamiento, usos, eficiencia y complejidad.

CATEGORIAS

Algoritmos y complejidad

CONDICIONES GENERALES

Algoritmo
Lenguaje de programación
Implementacion
Complejidad

PALABRAS CLAVE

Programación, Heaps, Sort, Monticulo,Ordenacion.

1) INTRODUCCION
 En este documento se estudiará dos algoritmos de ordenación, el
Inserción y Selección, los cuales son utilizados para ordenar elementos en
una estructura de datos.

Los algoritmos de este documento estan en seudocodigo y en escritos en

lenguaje C; todos aceptan un arreglo de A datos y un entero que representa
el tamaño del arreglo.

En cada algoritmos, explicamos detalladamente como funciona, su

complejidad de tiempo según el orden al que perteneces y cual de los dos es
mas eficiente al otro.

Esperamos que el lector no tenga problemas en entender este paper, esta

diseñado para ser entendido de una manera facil y didactica, inclyendo
imágenes para enter mejor el ordenamiento.

2) ALGORITMO DE ORDENACION HEAP-SORT

2.1) Concepto:
El ordenamiento por montículos (Heap sort) es un algoritmo de
ordenación no recursivo, no estable, con complejidad computacional
O(n log n). Este algoritmo consiste en almacenar todos los elementos
del vector a ordenar en un montículo (heap), y luego extraer el nodo
que queda como nodo raíz del montículo (cima) en sucesivas
iteraciones obteniendo el conjunto ordenado. Basa su funcionamiento
en una propiedad de los montículos, por la cual, la cima contiene
siempre el menor elemento (o el mayor, según se haya definido el
montículo) de todos los almacenados enél.

2.2) Caracteristicas:
- Un heap es un arreglo de n posiciones ocupado por los
elementos de la cola. (Nota: se utiliza un arreglo que inicia en la
posición 1 y no en cero, de tal manera que al implementarla en C
se tienen n+1 posiciones en el arreglo.)
- Se mapea un árbol binario de tal manera en el arreglo que el
nodo en la posicióni es el padre de los nodos en las posiciones
(2*i) y (2*i+1).El valor en un nodo es mayor o igual a los valores
de sus hijos. Por consiguiente ,el nodo padre tiene el mayor valor
de todo su subárbol.
 2.3) Ventajas:

1. Su desempeño es en promedio como el del quicksort, ya

que se comporta mejor que este en los peores casos.
Aunque tiene mejor desempeño que cualquier otro
método de ordenamiento, es mas
difícil de programar.2.Es uno de los mejores algoritmos
iterativos.
3. No necesita espacio adicional.
2.4) Desventajas:
1. Es lento que el Merge y el Quick , en la practica.
2. No es estable.

2.5) Funcionamiento:

Heap Sort consiste esencialmente en:

•Convertir el arreglo en un heap
•Construir un arreglo ordenado de atrás hacia adelante (mayor a menor)
repitiendo los siguientes pasos:
•Sacar el valor máximo en el heap (el de la posición 1)
•Poner ese valor en el arreglo ordenado
•Reconstruir el heap con un elemento menos
•Utilizar el mismo arreglo para el heap y el arreglo ordenado.

2.1.4. Algoritmo.
Pseudocodigo:
function heapsort(array A[0..n]):
montículo M
for i = 0..n:
insertar_en_monticulo(M, A[i])
for i = 0..n:
A[i] = extraer_cima_del_monticulo(M)
return A

Implementación en c++.
 #include <iostream>
#define max 100
using namespace std;
int main()
{
int A[max],j,item,temp,i,k,n,p,cont=0;
cout<<"Ingresa la cantidad de elementos del arreglo: ";
cin>>n;
for(i=1;i<=n;i++) cin >> A[i];
for(k=n;k>0;k--)
{
for(i=1;i<=k;i++)
{

item=A[i];
j=i/2;
while(j>0 && A[j]<item)
{
A[i]=A[j];
i=j;
j=j/2;
}
A[i]=item;
}
temp=A[1];
A[1]=A[k];
A[k]=temp;

}
cout<<"El orden es:"<<endl;
for(i=1;i<=n;i++)cout<<A[i] << endl;
system("pause>NULL");
return 0;
}

2.1.5. Cálculo de Complejidad:

Para analizar la complejidad de Heap-Sort lo primero que notamos es que se
ejecuta una vez el procedimiento Build-Heap y que el procedimiento Heapify se

ejecuta veces. Dado que Build-Heap toma tiempo y que Heapify

toma tiempo cuando se ejecuta desde la raíz de un heap con N elementos,
podemos asegurar que Heap-Sort toma tiempo:

En el peor caso. ¿Podemos dar una cota más ajustada como lo hicimos en el caso de
Build-Heap? La respuesta esta vez es no. Un argumento a favor para intentar
encontrar una cota más ajustada es el hecho de que Heapify no se ejecuta siempre
sobre un heap de N elementos, de hecho, en cada iteración se disminuye el valor de
π lo que nos dice que en cada iteración Heapify se ejecuta sobre un heap cada vez
más pequeño. Un argumento muy fuerte en contra de intentar encontrar una cota
más ajustada lo daremos en la sección?? Por ahora daremos las pautas de la

demostración de que Heap-Sort toma tiempo en el peor caso y que

por lo tanto la cota ya es ajustada.
En un árbol binario completo, la cantidad de hojas que hay a profundidad p es

exactamente luego, dado que Heapify toma tiempo proporcional a la altura del
heap en el peor caso, tenemos que el tiempo total de Heap-Sort está dado por la
sumatoria:

Con P la profundidad total del árbol. Ahora, la sumatoria interna cumple la siguiente
desigualdad:

Dado que el heap es un árbol semicompleto, sabemos que P es aproximadamente

por lo que el lado izquierdo de la desigualdad se acota de la siguiente

manera:

De donde obtenemos:
 De dónde resulta que la sumatoria es . Reemplazando este
resultado en nuestro cálculo inicial (1) obtenemos que HEAP – SORT Tiene
complejidad:

2.1.6. Conclusiones.
EL algoritmo Heap Sort tiene una eficiencia menor a los algoritmos recursivos que tiene
O(n log n), como el Merge o el Quick no requiere de recursividad masiva o múltiples arreglos
para trabajar. Esto lo hace atractivo para arreglos de miles de datos.

- Es un buen algoritmo, fácil, útil y eficiente.

3. REFERENCIAS:

1. Algoritmos de ordenación:
Sebastián Gurin (Cancerbero)
Coright © 2004 by Sebastián Gurin
2.[1] Aho, Alfred V.; John E. Hopcroft; Jefrrey D. Ullman: "Data
http://www.itlp.edu.mx/publica/tutoriales/estructdatos2/index.htm

http://www.teclaredo.edu.mx/takeyas/Apuntes/Estructura%20de%20Datos%20II/

http://www.estructuradedatos.galeon.com/pagprin.html

http://www.udlap.mx/~ccastane/Syllabus_Estructura_Datos/Notas_Estr_Datos/3_Ordenamien
tosSimples/3_Ordenamientos.html

http://dblinux.sis.epn.edu.ec/~cvillaci/ed6.html

http://info.pue.udlap.mx/~sainzmar/is211/AlgoritmosOrden.html

http://orbita.starmedia.com/wacosta2000/pascal.htm

http://www.algoritmia.net/articles.php?id=31&leng=Pascal
Structures and Algorithms"; 1983. [AHO-83].