FACULTAD DE INFORMATICA Y CIENCIAS APLICADAS

ESCUELA DE INFORMATICA

ASIGNATURA:

Mtodos de Programacin II

CATEDRTICO:

Ing. Jos Orlando Girn

TEMA:

Mtodo de Ordenacin HeapSort

ALUMNO(S):

Christian Alexander Melendez Diaz 35-6694-2014

 INDICE

Introduccin a HeapSort ............................................................................................................ 3

Objetivos .................................................................................................................................... 4

Marco Terico ............................................................................................................................ 5

Ejecucin de algoritmo en Java: ................................................................................................ 6

Comparacin con mtodos de shellSort y quickSort.................................................................. 8

Conclusin ............................................................................................................................... 10

Bibliografa ............................................................................................................................... 11
 Introduccin a HeapSort

El Heapsort es un mtodo de ordenamiento por seleccin tipo rbol que organiza los datos de
forma tal que los nodos del nivel ms bajo estn ms a la izquierda posible y eso permite que
al recorrer el camino desde la raz hacia las hojas los datos se encuentren en orden
descendente y la informacin sea almacenada

Algoritmos de ordenamiento Heapsort

Es un mtodo de ordenamiento por seleccin

Heap: es un rbol binario de altura mnima, en que los nodos del nivel ms bajo estn ms a la
izquierda posible

La informacin es almacenada de manera que al recorrer un camino desde la raz hacia las
hojas, los datos se encuentran en orden descendente

Si se presenta este arreglo resultante como un rbol se observa que cada elemento es el padre
de los otros elementos z[i], z[i+1] puesto que es una estructura con un grupo el cual j<_i/2

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.

Algoritmos de seleccin del Heapsort

El vector debe tener estructura de montculo, 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
mximo, ya que en este caso la ordenacin se realiza en sentido inverso.

La estructura es un montculo facilita esta bsqueda y la hace del orden LOG(N)

Por lo tanto el costo final ser log(n) para cada elemento que se quiera colocar en la zona

ordenada es decir
 Objetivos

Conocer los conceptos generales sobre el algoritmo de ordenamiento por mtodo

Heapsort

Aplicar algunos conceptos de las estructuras de datos relacionadas con el algoritmo

Conocer la importancia que tienen algoritmo de ordenamiento por mtodo Heapsort en

el da a da dentro del mbito informtico y dentro de los diferentes sistemas que usamos
Marco Terico

El ordenamiento por montculos (heapsort en ingls) es un algoritmo de ordenamiento no

recursivo, no estable, con complejidad computacional

Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un montculo
(heap), y luego extraer el nodo que queda como nodo raz del montculo (cima) en sucesivas
iteraciones obteniendo el conjunto ordenado. Basa su funcionamiento en una propiedad de los
montculos, por la cual, la cima contiene siempre el menor elemento (o el mayor, segn se haya
definido el montculo) de todos los almacenados en l. El algoritmo, despus de cada
extraccin, recoloca en el nodo raz o cima, la ltima hoja por la derecha del ltimo nivel. Lo
cual destruye la propiedad heap del rbol. Pero, a continuacin realiza un proceso de
"descenso" del nmero insertado de forma que se elige a cada movimiento el mayor de sus dos
hijos, con el que se intercambia. Este intercambio, realizado sucesivamente "hunde" el nodo en
el rbol restaurando la propiedad montculo del arbol y dejndo paso a la siguiente extraccin
del nodo raz.

El algoritmo, en su implementacin habitual, tiene dos fases. Primero una fase de construccin
de un montculo a partir del conjunto de elementos de entrada, y despus, una fase de
extraccin sucesiva de la cima del montculo. La implementacin del almacn de datos en el
heap, pese a ser conceptualmente un rbol, puede realizarse en un vector de forma fcil.

Cada nodo tiene dos hijos y por tanto, un nodo situado en la posicin i del vector, tendr a sus
hijos en las posiciones 2 x i, y 2 x i +1 suponiendo que el primer elemento del vector tiene un
ndice = 1. Es decir, la cima ocupa la posicin inicial del vector y sus dos hijos la posicin
segunda y tercera, y as, sucesivamente. Por tanto, en la fase de ordenacin, el intercambio
ocurre entre el primer elemento del vector (la raz o cima del rbol, que es el mayor elemento
del mismo) y el ltimo elemento del vector que es la hoja ms a la derecha en el ltimo nivel.

El rbol pierde una hoja y por tanto reduce su tamao en un elemento. El vector definitivo y
ordenado, empieza a construirse por el final y termina por el principio.
Ejecucin de algoritmo en Java:

public class Metodos{

public static void main(String a[]){
long t1 = System.nanoTime();
long t2 = System.nanoTime() ;

int i;
int arr[] = {19,24,25,47,26,28,29,30,31,32,34,35,36,37,39,40,41,42,43,44,};

System.out.println("\n Heap Sort\n---------------\n");

System.out.println("\n Unsorted Array\n\n");
for (i = 0; i < arr.length; i++)
System.out.print(" "+arr[i]);
for(i=arr.length; i>1; i--){
fnSortHeap(arr, i - 1);
}
System.out.println("\n Sorted array\n---------------\n");
System.out.println("El tiempo de demora es :" + t2 + " nanosegundos");
for (i = 0; i < arr.length; i++)
System.out.print(" "+arr[i]);
}

public static void fnSortHeap(int array[], int arr_ubound){

int i, o;
int lChild, rChild, mChild, root, temp;
root = (arr_ubound-1)/2;

for(o = root; o >= 0; o--){

for(i=root;i>=0;i--){
lChild = (2*i)+1;
rChild = (2*i)+2;
if((lChild <= arr_ubound) && (rChild <= arr_ubound)){
if(array[rChild] >= array[lChild])
mChild = rChild;
else
mChild = lChild;
}
else{
if(rChild > arr_ubound)
mChild = lChild;
else
mChild = rChild;
}

if(array[i] < array[mChild]){

temp = array[i];
array[i] = array[mChild];
array[mChild] = temp;
}
}
}
temp = array[0];
array[0] = array[arr_ubound];
 array[arr_ubound] = temp;
return;

}
}
Comparacin con mtodos de shellSort y quickSort

El mtodo Shell es una versin mejorada del mtodo de insercin directa. Recibe su nombre
en honor de su autor, Donalds L. shell, que no propuso en 1959. Ese momento donde se conoce
comunicacin con incrementos decrecientes.

En el mtodo de ordenacin insercin directa cada elemento se compara para su ubicacin

correcta en el arreglo con los elementos que se encuentran en su parte izquierda. si el elemento
a insertar es ms pequeo que el grupo de elementos que se encuentran a su izquierda, ser
necesario efectuar varias comparaciones antes de su ubicacin.

Shell propone que las comparaciones entre elementos se efectu con saltos de mayor tamao,
pero con incrementos decrecientes; as, los elementos quedaran ordenados en el arreglo ms
rpidamente.

El mtodo de ordenacin quicksort es actualmente el ms eficiente y veloz de los mtodos

de ordenacin interna. Es tambin conocido como el mtodo rpido y de ordenacin por
particin. Este mtodo es una mejora sustancial del mtodo del intercambio directo y se
denomina quicksort - rpido- por la velocidad con que ordena los elementos del arreglo. Su
autor, C. A. Hoare, lo llamo as . La idea central de este algoritmo consiste en lo siguiente:

1. Se toma un elemento X de una posicin del arreglo.

2. Se trata de ubicar a X en la posicin correcta del arreglo, de tal forma que todos los elementos
que se encuentren a su izquierda sean menores o iguales a X.
3. Se repiten los pasos anteriores, pero ahora para los conjuntos de datos que se encuentran a
la izquierda y a la derecha de la posicin de X en el arreglo.
4. El proceso termina cuando todos los elementos se encuentran en su posicin correcta en el
arreglo.

Se debe seleccionar, entonces, un elemento X cualquiera. En este caso se seleccionara A[1].

se comienza a recorrer el arreglo de derecha a izquierda comprando si los elementos son
mayores o iguales a X. Si un elemento no cumple con esta condicin, se intercambia aquellos
y se almacenan en una variable la posicin del elemento intercambiado ( se acota el arreglo
por la derecha).
Se inicia nuevamente el recorrido, pero ahora de izquierda a derecha, comparando si los
elementos son menores o iguales a X.
Las diferencias y comparaciones del mtodo de ordenamiento HeapSort con los dos algoritmos
vistos anteriormente es que a diferencia de los otros dos, Heapsort consiste en almacenar todos
los elementos del vector a ordenar en un montculo (heap), y luego extraer el nodo que queda
como nodo raz del montculo (cima) en sucesivas iteraciones obteniendo el conjunto ordenado.
Basa su funcionamiento en una propiedad de los montculos, por la cual, la cima contiene
siempre el menor elemento (o el mayor, segn se haya definido el montculo) de todos los
almacenados en l. El algoritmo, despus de cada extraccin, recoloca en el nodo raz o cima,
la ltima hoja por la derecha del ltimo nivel. Lo cual destruye la propiedad heap del rbol. Pero,
a continuacin realiza un proceso de "descenso" del nmero insertado de forma que se elige a
cada movimiento el mayor de sus dos hijos, con el que se intercambia. Este intercambio,
realizado sucesivamente "hunde" el nodo en el rbol restaurando la propiedad montculo del
arbol y dejndo paso a la siguiente extraccin del nodo raz.

El algoritmo, en su implementacin habitual, tiene dos fases. Primero una fase de construccin
de un montculo a partir del conjunto de elementos de entrada, y despus, una fase de
extraccin sucesiva de la cima del montculo. La implementacin del almacn de datos en el
heap, pese a ser conceptualmente un rbol, puede realizarse en un vector de forma fcil. Cada
nodo tiene dos hijos y por tanto, un nodo situado en la posicin i del vector, tendr a sus hijos
en las posiciones 2 x i, y 2 x i +1 suponiendo que el primer elemento del vector tiene un ndice
= 1. Es decir, la cima ocupa la posicin inicial del vector y sus dos hijos la posicin segunda y
tercera, y as, sucesivamente. Por tanto, en la fase de ordenacin, el intercambio ocurre entre
el primer elemento del vector (la raz o cima del rbol, que es el mayor elemento del mismo) y
el ltimo elemento del vector que es la hoja ms a la derecha en el ltimo nivel. El rbol pierde
una hoja y por tanto reduce su tamao en un elemento. El vector definitivo y ordenado, empieza
a construirse por el final y termina por el principio.
 Conclusin

En el presente trabajo se comprendieron las generalidades sobre mtodo de ordenamiento

HeapSort, as como ejemplos de sus usos para los distintos casos de aplicacin y que son
fundamentales en el desarrollo de algunas operaciones y anlisis de la vida diaria
En fin, se puede tambin observar como hay mucha informacin acerca del mtodo de
ordenamiento HeapSort valindose, por la eficiencia que presenta a la hora de realizar las
operaciones de ordenamiento que son permitidas para el manejo de la informacin.

El desarrollo de este trabajo trata de resumir no slo con el nimo de cumplir con las fechas y
requisitos establecidos por el mismo, sino que tambin, con el nimo de aprender y
retroalimentar todos los conceptos que en este resumen han sido vertidos, teniendo el cuidado
de aprender lo ms que se haya podido sobre el resumen que se ha realizado.
Bibliografa

SITIOS WEB

https://es.wikipedia.org/wiki/Heapsort
http://es.slideshare.net/jhosep94/heap-sort-15397805
http://estructuras-de-datos.wikispaces.com/Heapsort
www.ecured.cu/index.php/Heapsort
www.metodopormonticulos.blogspot.com/
www.ime.usp.br/~pf/algoritmos/aulas/hpsrt.html
http://upcanalisisalgoritmos.wikispaces.com/Grupo+5+-+Parcial+2