HEAP SORT
Algoritmo 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 (no
necesariamente 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 ser
humano es capaz de implementar una metodología propia para ordenar un conjunto de
elementos, esta tarea se vuelve extremadamente complicada cuando el número de elementos es
grande, 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 datos
desordenados.
• Su desempeño es en promedio tan
bueno como el Quicksort.
• No utiliza memoria adicional.
DESVENTAJAS
• No es estable, ya que se comporta de
manera ineficaz con datos del mismo
valor
• Este método es mucho mas complejo
que 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
5
FALSO ¿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 ALGORITMO
FIN 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.

Algoritmo de ordenamiento: Heap Sort

  • 1.
    HEAP SORT Algoritmo deOrdenamiento Integrantes:  Daniel Gomez Jaramillo.  Tania Landívar Ordoñez  Jonnathan Peñaranda Sarmiento.  Gabriela Verdugo Velesaca.
  • 2.
    CONTENIDO 1. Introducción 2. Descripcióndel 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.
  • 3.
    INTRODUCCIÓN Ordenar una listaes la operación de arreglar los elementos de acuerdo algún criterio (no necesariamente 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 ser humano es capaz de implementar una metodología propia para ordenar un conjunto de elementos, esta tarea se vuelve extremadamente complicada cuando el número de elementos es grande, 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.
  • 4.
    DESCRIPCIÓN DEL MÉTODOHEAP 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
  • 5.
    VENTAJAS Y DESVENTAJAS VENTAJAS •Funciona efectivamente con datos desordenados. • Su desempeño es en promedio tan bueno como el Quicksort. • No utiliza memoria adicional. DESVENTAJAS • No es estable, ya que se comporta de manera ineficaz con datos del mismo valor • Este método es mucho mas complejo que los demás.
  • 6.
    FUNCIONAMIENTO DEL MÉTODOHEAPSORT 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.
  • 7.
    FUNCIONAMIENTO DEL MÉTODOHEAP SORT <5 7 27 3 2 126, >, , ,,,
  • 8.
    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
  • 9.
    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
  • 10.
    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
  • 11.
    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 5 FALSO ¿5<3?
  • 12.
    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
  • 13.
    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
  • 14.
    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
  • 15.
    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
  • 16.
    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
  • 17.
    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
  • 18.
    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
  • 19.
    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
  • 20.
    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
  • 21.
    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
  • 22.
    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
  • 23.
    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
  • 24.
    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
  • 25.
    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
  • 26.
    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
  • 27.
    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
  • 28.
    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
  • 29.
    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
  • 30.
    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
  • 31.
    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
  • 32.
    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
  • 33.
    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
  • 34.
    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
  • 35.
    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
  • 36.
    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
  • 37.
    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
  • 38.
    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
  • 39.
    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
  • 40.
    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
  • 41.
    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
  • 42.
    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
  • 43.
    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
  • 44.
    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
  • 45.
    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
  • 46.
    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
  • 47.
    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
  • 48.
    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
  • 49.
    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
  • 50.
    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
  • 51.
    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
  • 52.
    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
  • 53.
    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
  • 54.
    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
  • 55.
    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 ALGORITMO FIN ETAPA 2
  • 56.
  • 57.
    COMPLEJIDAD DE HEAPSORT 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.
  • 58.
    APLICACIONES Y USOSEN 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.
  • 59.
    CONCLUSIONES La principal ventajade 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.
  • 60.
    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
  • 61.
    ¡¡ GRACIAS !! Estructurade Datos y Análisis de Algoritmos.