Algoritmo de ordenamiento: Heap Sort
-
Upload
daniel-gomez-jaramillo -
Category
Software
-
view
115 -
download
3
Transcript of 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.