Algoritmo de ordenamiento: Heap Sort

HEAP SORTAlgoritmo de Ordenamiento

Integrantes:

Daniel Gomez Jaramillo.

Tania Landívar Ordoñez

Jonnathan Peñaranda Sarmiento.

Gabriela Verdugo Velesaca.

CONTENIDO

1. Introducción

2. Descripción del método

I. Ventajas y desventajas.

II. Funcionamiento

III. Complejidad computacional

IV. Aplicaciones y usos en la actualidad

3. Conclusiones

4. Bibliografía.

5. Agradecimientos.

INTRODUCCIÓN

Ordenar una lista es la operación de arreglar los elementos de acuerdo algún criterio (nonecesariamente matemático). En el caso de tratarse de números el criterio de orden podría ser“<”, es decir, ordenar los elementos de la lista de menor a mayor. Aunque naturalmente un serhumano es capaz de implementar una metodología propia para ordenar un conjunto deelementos, esta tarea se vuelve extremadamente complicada cuando el número de elementos esgrande, puesto que se necesitaría mucho tiempo y se podrían cometer errores.

Ejemplos de esta situación podrían

ser: ordenar alfabéticamente a los

habitantes de una ciudad, ordenar

una biblioteca, clasificar

alfabéticamente las palabras de un

lenguaje, ordenar una serie de

paginas de internet, ordenar un

conjunto de números enteros, etc.

DESCRIPCIÓN DEL MÉTODO HEAP SORT

ORIGEN

Fue publicado originalmente por J.W.J. Williams llamándolo "Algorithm 232" en la revista"Communications of the ACM" en 1964.

Este algoritmo consiste en ordenar en un arbol y luego extraer del nodo que queda como raíz

en sucesivas iteraciones obteniendo el conjunto ordenado. Basa su funcionamiento en una

propiedad de montículos, por la cual, la cima siempre dependiendo de cómo se

defina contendrá el mayor o menor elemento del montículo.

DESCRIPCIÓN GENERAL

VENTAJAS Y DESVENTAJAS

VENTAJAS

• Funciona efectivamente con datosdesordenados.

• Su desempeño es en promedio tanbueno como el Quicksort.

• No utiliza memoria adicional.

DESVENTAJAS

• No es estable, ya que se comporta demanera ineficaz con datos del mismovalor

• Este método es mucho mas complejoque los demás.

FUNCIONAMIENTO DEL MÉTODO HEAPSORT

Este algoritmo consiste en almacenar todos los elementos en un montículo y luego extraer el nodo que queda como raíz en iteraciones sucesivas obteniendo el conjunto ordenado.

Para esto el método realiza los siguientes pasos:

• 1. Se construye el Heap/montículo a partir del arreglo original.

• 2. La raíz se coloca en el arreglo.

• 3. El último elemento del montículo se vuelve la raíz.

• 4. La nueva raíz se intercambia con el elemento de mayor valor por nivel.

• 5. Tras el paso anterior la raíz vuelve a ser el mayor del montículo.

• 6. Se repite el paso 2 hasta que quede el arreglo ordenado.

FUNCIONAMIENTO DEL MÉTODO HEAP SORT

<5 7 27 3 2 126, >, , ,,,

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}5

7

6

27

23 12

¿5<7?VERDADERO

árbol

ETAPA 1

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}5

7

6

27

23 12

¿5<7?VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}5

6

27

23 12

¿5<3?FALSO

7

5

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}5

6

27

23 12

¿5<2?FALSO

7

5FALSO ¿5<3?

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}5

6

27

23 12

¿7<5?FALSO 7

5¿5<2?FALSO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}5

6

27

23 12

¿7<27?7

5

VERDADERO¿7<5?FALSO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

6

27

23 12

¿7<27?7

5

VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623 12

5

27

7

¿7<6? FALSO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623 12

5

27

7

¿7<6? FALSO ¿7<12? VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623 12

5

27

7

¿7<12? VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

5

27

7

12

¿27<12? FALSO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

5

27

7

12

¿27<12? FALSO

27lista_ordenada

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

5 12

27

7

27lista_ordenada

FIN ETAPA 1

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

5 12

7

27lista_ordenada

FIN ETAPA 1ETAPA 2

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

5 12

7

27lista_ordenada

¿5<12?

VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

5 12

7

27lista_ordenada

¿5<12?

VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

12

27lista_ordenada

5

7 ¿7<12? VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

12

27lista_ordenada

5

7 ¿7<12? VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

27lista_ordenada

5 7

12

¿7<6? FALSO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

27lista_ordenada

5

¿12<7? FALSO

¿7<6? FALSO

7

12

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

623

27lista_ordenada

5

¿12<7? FALSO

7

12

12

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

23

27lista_ordenada

5 7

12

6

2712

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

23

27lista_ordenada

5 7

6

2712

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

23

5 7

6

27lista_ordenada 2712

¿5<7?

VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

23

5 7

6

27lista_ordenada 2712

¿5<7?

VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

23

5

¿6<7? VERDADERO

7

6

27lista_ordenada 2712

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

23

5

¿6<7? VERDADERO

7

6

27lista_ordenada 2712

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

23

5 6

7

272712lista_ordenada 2727127

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

3

5 6

lista_ordenada 2727127

2

7

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

3

lista_ordenada 2727127

2

5 6¿5<6?

VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

3

5 6

lista_ordenada 2727127

2

¿5<6?

VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

6

lista_ordenada 2727127

2

3

5

¿2<6? VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

6

lista_ordenada 2727127

2 ¿2<6? VERDADERO

3

5

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

2727127

2

6

6lista_ordenada

3

5

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

lista_ordenada

5 2

3

6

27271276

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

lista_ordenada 27271276

5 2

3

¿5<2?

FALSO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

5 2

3

lista_ordenada 27271276

¿3<5?VERDADERO

¿5<2?

FALSO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

2

lista_ordenada 27271276

3

5

¿3<5?VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

lista_ordenada 27271276

3 2

5

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

27271276

3 5

2

lista_ordenada5

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

27271276

3

2

5lista_ordenada

¿2<3?VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

27271276

3

2

5lista_ordenada

¿2<3?VERDADERO

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

27271276

2

3

5lista_ordenada

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

27271276

3

2

5lista_ordenada3

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

27271276

2

5lista_ordenada 3

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

27271276

2

53lista_ordenada

2

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

272712765lista_ordenada 32

árbol = NULL

2

FIN ETAPA 2

heap_sort(árbol, lista_ordenada)

{

while(árbol != NULL)

{

insertar_en_monticulo(árbol);

extraer_cima(árbol,lista_ordenada);

borrar_nodo(árbol,pos)

}

}

272712765lista_ordenada 32

árbol = NULL

FIN DEL ALGORITMOFIN ETAPA 2

272712765lista_ordenada 32

RESULTADO:

COMPLEJIDAD DE HEAP SORT

El algoritmo de ordenación por montículos o Heap Sort recorre el conjunto de elementos

desde la posición de la mitad hasta la primera organizando el montículo correspondiente a

dicho elemento. Una vez terminado este proceso, se inicia el proceso de ordenación

intercambiando el primer elemento por el último del arreglo y reorganizando el montículo a

partir de la primera posición.

La complejidad del algoritmo de ordenación por

montículos es O(n log n) teniendo en cuenta que el

proceso de organizar el montículo en el peor caso

solamente tiene que hacer intercambios sobre una sola

línea de elementos desde la raíz del árbol hasta alguna

de las hojas para un máximo de n log (n) intercambios.

APLICACIONES Y USOS EN LA ACTUALIDAD

Una de las mas grandes aplicaciones de Heap Sort es construir colas de prioridad con la idea que

busque los procesos que llevan la mayor carga de prioridad dado una gran cantidad de procesos

por hacer.

Otra aplicación es la de Programación de Intervalos, en donde se tiene una lista de tareas con un

tiempo de inicio y fin y deseamos hacer tantas tareas como sean posibles en un periodo de tiempo

limitado.

En esencia una aplicación o algoritmo que trate de ordenar una lista de elementos dependerán

eficientemente en un algoritmo de ordenamiento, y el método Heap Sort puede proveernos de tal

función.

CONCLUSIONES

La principal ventaja de este método de ordenamiento es su eficiencia en el tiempo de ejecución,

el cual es O(n log n). La eficiencia de la memoria, para la implementación del algoritmo es O(1),

tanto en la forma iterativa como recursiva.

Concluyendo, decimos que este método es conveniente

usarlo cuando se trata de ordenar arreglos o listas grandes,

ya que cuando por ejemplo, este se encuentra con

elementos repetidos, el algoritmo suele tener

inconvenientes a diferencia de otros métodos como el Quick

Sort y el Merge Sort.

REFERENCIAS BIBLIOGRÁFICAS

• Dr. GuillermoCámara Chávez. (2015). Ordenación. 06/06/2016, de homepages. Sitio web:

http://homepages.dcc.ufmg.br/~gcamarac/cursos/algoritmia/ordenacion_4pages_sec.pdf

• Conrado Martínez. (2012). Algorítmica: Heaps y heapsort. 06/06/2016, de algorithmics Sitio

web: http://algorithmics.lsi.upc.edu/docs/pqueues.pdf

• Springer-Verlag (1991). “Algorithms and Data Strctures”. Ottawa, Canada. 06/06/2016,

Disponible en: https://books.google.com.ec/books?id=NRrcsIJZAYMC

¡¡ GRACIAS !!

Estructura de Datos y Análisis de Algoritmos.