SlideShare una empresa de Scribd logo
1 de 61
Descargar para leer sin conexión
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.

Más contenido relacionado

La actualidad más candente

Ordenamiento por monticulo (heapsort)
Ordenamiento por monticulo (heapsort)Ordenamiento por monticulo (heapsort)
Ordenamiento por monticulo (heapsort)edopaz
 
Ordenamientos burbuja e inserción
Ordenamientos burbuja e inserciónOrdenamientos burbuja e inserción
Ordenamientos burbuja e inserciónAlvaro Enrique Ruano
 
Estructura de datos: lista, pilas y colas
Estructura de datos: lista, pilas y colasEstructura de datos: lista, pilas y colas
Estructura de datos: lista, pilas y colasHuascar Génere
 
Método de Búsqueda Hash
Método de Búsqueda HashMétodo de Búsqueda Hash
Método de Búsqueda HashBlanca Parra
 
Metodos de ordenacion radix sort
Metodos de ordenacion radix sortMetodos de ordenacion radix sort
Metodos de ordenacion radix sorttephyfree
 
METODOS DE ORDENACION ORDENAMIENTO Y BUSQUEDA (ALGORITMOS)
METODOS DE ORDENACION ORDENAMIENTO Y BUSQUEDA (ALGORITMOS)METODOS DE ORDENACION ORDENAMIENTO Y BUSQUEDA (ALGORITMOS)
METODOS DE ORDENACION ORDENAMIENTO Y BUSQUEDA (ALGORITMOS)Fuerza Auriazul
 
Listas como estructura de datos..
Listas como estructura de datos..Listas como estructura de datos..
Listas como estructura de datos..NANO-06
 
Estructura de Datos - Unidad 4 Estructuras no lineales
Estructura de Datos - Unidad 4 Estructuras no linealesEstructura de Datos - Unidad 4 Estructuras no lineales
Estructura de Datos - Unidad 4 Estructuras no linealesJosé Antonio Sandoval Acosta
 
Estructura de datos - Unidad 1: Introducción a las estructuras de datos
Estructura de datos - Unidad 1: Introducción a las estructuras de datosEstructura de datos - Unidad 1: Introducción a las estructuras de datos
Estructura de datos - Unidad 1: Introducción a las estructuras de datosJosé Antonio Sandoval Acosta
 
Estructura de Datos - árboles y grafos
Estructura de Datos - árboles y grafosEstructura de Datos - árboles y grafos
Estructura de Datos - árboles y grafosMiguel Rodríguez
 
Arboles - estructura de datos
Arboles - estructura de datos Arboles - estructura de datos
Arboles - estructura de datos Kaneki04
 

La actualidad más candente (20)

Arboles Binarios
Arboles BinariosArboles Binarios
Arboles Binarios
 
Ordenamiento por monticulo (heapsort)
Ordenamiento por monticulo (heapsort)Ordenamiento por monticulo (heapsort)
Ordenamiento por monticulo (heapsort)
 
Ordenamientos burbuja e inserción
Ordenamientos burbuja e inserciónOrdenamientos burbuja e inserción
Ordenamientos burbuja e inserción
 
Heap sort
Heap sortHeap sort
Heap sort
 
Estructura de datos: lista, pilas y colas
Estructura de datos: lista, pilas y colasEstructura de datos: lista, pilas y colas
Estructura de datos: lista, pilas y colas
 
Estructura de Datos - Unidad 6 Metodos de busqueda
Estructura de Datos - Unidad 6 Metodos de busquedaEstructura de Datos - Unidad 6 Metodos de busqueda
Estructura de Datos - Unidad 6 Metodos de busqueda
 
Heap sort
Heap sortHeap sort
Heap sort
 
Metodo burbuja
Metodo burbujaMetodo burbuja
Metodo burbuja
 
Método de Búsqueda Hash
Método de Búsqueda HashMétodo de Búsqueda Hash
Método de Búsqueda Hash
 
Metodos de ordenacion radix sort
Metodos de ordenacion radix sortMetodos de ordenacion radix sort
Metodos de ordenacion radix sort
 
METODOS DE ORDENACION ORDENAMIENTO Y BUSQUEDA (ALGORITMOS)
METODOS DE ORDENACION ORDENAMIENTO Y BUSQUEDA (ALGORITMOS)METODOS DE ORDENACION ORDENAMIENTO Y BUSQUEDA (ALGORITMOS)
METODOS DE ORDENACION ORDENAMIENTO Y BUSQUEDA (ALGORITMOS)
 
Listas como estructura de datos..
Listas como estructura de datos..Listas como estructura de datos..
Listas como estructura de datos..
 
Estructura de Datos - Unidad 4 Estructuras no lineales
Estructura de Datos - Unidad 4 Estructuras no linealesEstructura de Datos - Unidad 4 Estructuras no lineales
Estructura de Datos - Unidad 4 Estructuras no lineales
 
Árboles binarios, ABB y AVL
Árboles binarios, ABB y AVLÁrboles binarios, ABB y AVL
Árboles binarios, ABB y AVL
 
Ordenamiento shell
Ordenamiento shellOrdenamiento shell
Ordenamiento shell
 
Estructura de datos - Unidad 1: Introducción a las estructuras de datos
Estructura de datos - Unidad 1: Introducción a las estructuras de datosEstructura de datos - Unidad 1: Introducción a las estructuras de datos
Estructura de datos - Unidad 1: Introducción a las estructuras de datos
 
Estructura de Datos - árboles y grafos
Estructura de Datos - árboles y grafosEstructura de Datos - árboles y grafos
Estructura de Datos - árboles y grafos
 
Arboles - estructura de datos
Arboles - estructura de datos Arboles - estructura de datos
Arboles - estructura de datos
 
Estructura de Datos - Estructuras no lineales
Estructura de Datos - Estructuras no linealesEstructura de Datos - Estructuras no lineales
Estructura de Datos - Estructuras no lineales
 
Quicksort
QuicksortQuicksort
Quicksort
 

Similar a Algoritmo de ordenamiento: Heap Sort

Similar a Algoritmo de ordenamiento: Heap Sort (20)

Comparativa entre Algoritmos de Ordenamiento
Comparativa entre Algoritmos de OrdenamientoComparativa entre Algoritmos de Ordenamiento
Comparativa entre Algoritmos de Ordenamiento
 
Algoritmos Ordenamiento
Algoritmos OrdenamientoAlgoritmos Ordenamiento
Algoritmos Ordenamiento
 
algoritmo de ordenamiento.pptx
algoritmo de ordenamiento.pptxalgoritmo de ordenamiento.pptx
algoritmo de ordenamiento.pptx
 
Investigacion ed (pseudocodigo, algoritmo, listas, colas, arboles)
Investigacion ed (pseudocodigo, algoritmo, listas, colas, arboles)Investigacion ed (pseudocodigo, algoritmo, listas, colas, arboles)
Investigacion ed (pseudocodigo, algoritmo, listas, colas, arboles)
 
Ordenamientos de vectores
Ordenamientos de vectoresOrdenamientos de vectores
Ordenamientos de vectores
 
Metodos de odenamiento de vctores
Metodos de odenamiento de vctoresMetodos de odenamiento de vctores
Metodos de odenamiento de vctores
 
concepto de estructuras de datos
concepto de estructuras de datosconcepto de estructuras de datos
concepto de estructuras de datos
 
Heap sort
Heap sortHeap sort
Heap sort
 
Heapsort
HeapsortHeapsort
Heapsort
 
Ordenamiento en C++
Ordenamiento en C++Ordenamiento en C++
Ordenamiento en C++
 
Tema5
Tema5Tema5
Tema5
 
Ordenacion y busqueda
Ordenacion y busquedaOrdenacion y busqueda
Ordenacion y busqueda
 
Informe ordenamiento
Informe ordenamientoInforme ordenamiento
Informe ordenamiento
 
1_Metodos.doc
1_Metodos.doc1_Metodos.doc
1_Metodos.doc
 
Unidad 1 1
Unidad 1   1Unidad 1   1
Unidad 1 1
 
Métodos de ordenamiento
Métodos de ordenamiento Métodos de ordenamiento
Métodos de ordenamiento
 
Complejidad de Algoritmos
Complejidad de AlgoritmosComplejidad de Algoritmos
Complejidad de Algoritmos
 
Estructura de Datos - Unidad VI: Métodos de Búsqueda
Estructura de Datos - Unidad VI: Métodos de BúsquedaEstructura de Datos - Unidad VI: Métodos de Búsqueda
Estructura de Datos - Unidad VI: Métodos de Búsqueda
 
Algoritmo por seleccion
Algoritmo por seleccionAlgoritmo por seleccion
Algoritmo por seleccion
 
Recursividad, Ordenacion y Busqueda
Recursividad, Ordenacion y BusquedaRecursividad, Ordenacion y Busqueda
Recursividad, Ordenacion y Busqueda
 

Más de Daniel Gomez Jaramillo

Más de Daniel Gomez Jaramillo (15)

DotVVM Fundamentals
DotVVM FundamentalsDotVVM Fundamentals
DotVVM Fundamentals
 
Servicios de base de datos multimodelo NoSQL con Azure CosmosDB y aplicación...
Servicios de base de datos multimodelo  NoSQL con Azure CosmosDB y aplicación...Servicios de base de datos multimodelo  NoSQL con Azure CosmosDB y aplicación...
Servicios de base de datos multimodelo NoSQL con Azure CosmosDB y aplicación...
 
Microsoft Cognitive Services y el lado humano de las aplicaciones inteligentes.
Microsoft Cognitive Services y el lado humano de las aplicaciones inteligentes.Microsoft Cognitive Services y el lado humano de las aplicaciones inteligentes.
Microsoft Cognitive Services y el lado humano de las aplicaciones inteligentes.
 
HTML y Alojamiento en Azure.
HTML y Alojamiento en Azure. HTML y Alojamiento en Azure.
HTML y Alojamiento en Azure.
 
Internet y seguridad en redes
Internet y seguridad en redesInternet y seguridad en redes
Internet y seguridad en redes
 
Sistema de gestión de base de datos SQL UC
Sistema de gestión de base de datos SQL UCSistema de gestión de base de datos SQL UC
Sistema de gestión de base de datos SQL UC
 
Colecciones en Scala
Colecciones en ScalaColecciones en Scala
Colecciones en Scala
 
Codificación de Huffman
Codificación de Huffman Codificación de Huffman
Codificación de Huffman
 
Algoritmos de ordenamiento externo sobre archivos
Algoritmos de ordenamiento externo sobre archivosAlgoritmos de ordenamiento externo sobre archivos
Algoritmos de ordenamiento externo sobre archivos
 
Reproductor de música DG Player
Reproductor de música DG PlayerReproductor de música DG Player
Reproductor de música DG Player
 
Colecciones en Python
Colecciones en PythonColecciones en Python
Colecciones en Python
 
Paradigmas de la programación
Paradigmas de la programación Paradigmas de la programación
Paradigmas de la programación
 
Fuerzas de rozamiento
Fuerzas de rozamientoFuerzas de rozamiento
Fuerzas de rozamiento
 
Clases y objetos en Java
Clases y objetos en JavaClases y objetos en Java
Clases y objetos en Java
 
Programación dinámica
Programación dinámicaProgramación dinámica
Programación dinámica
 

Algoritmo de ordenamiento: Heap Sort

  • 1. HEAP SORT Algoritmo de Ordenamiento Integrantes:  Daniel Gomez Jaramillo.  Tania Landívar Ordoñez  Jonnathan Peñaranda Sarmiento.  Gabriela Verdugo Velesaca.
  • 2. 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.
  • 3. 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.
  • 4. 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
  • 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É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.
  • 7. FUNCIONAMIENTO DEL MÉTODO HEAP 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
  • 57. 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.
  • 58. 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.
  • 59. 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.
  • 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 !! Estructura de Datos y Análisis de Algoritmos.