Universidad Tecnológica Centroamericana

Facultad De Ingeniería

Investigación Final
Estructuras De Datos II

Presentado por:
Andrea José Mendoza Castañeda
José Neftalí Lagos Lara
Sarah Gabriela Castelar Pineda
Jonrry Wendell Enamorado Contreras

Docente:
Ing. Reynod Bocanegra

Fecha de Entrega:
26 de marzo de 2019.
 Tabla de Contenido

Resumen ....................................................................................................................... 3

Introducción .................................................................................................................. 5

Marco Teórico .............................................................................................................. 6

Metodología ................................................................................................................ 11

Investigación Aplicada ................................................................................................ 12

Conclusiones y Recomendaciones ............................................................................... 13

Bibliografía ................................................................................................................. 15

P á g i n a 2 | 17
 Resumen

Un algoritmo de ordenamiento es un algoritmo utilizado en computación y

matemáticas para colocar una selección de datos en una secuencia dictada por una

relación de orden específica, según las necesidades solicitadas o requeridas según la

situación a mano. Como resultado final, se obtiene un reordenamiento o permutación de

la colección original de datos, satisfaciendo las condiciones de la relación establecida

anteriormente.

Desde el inicio de las ciencias de la computación, ordenar y manejar datos de una

manera fácil, óptima y eficiente ha sido uno de los principales campos de investigación

del área. Esto se debe a que existe posiblemente una cantidad infinita de soluciones para

un mismo problema, abriendo así las puertas para que el programador pueda explorar su

creatividad e innovación. Sin embargo, para distintos casos existen distintas soluciones,

algunas más apropiadas que otras. A continuación, se presentan tres diferentes métodos

sistemáticos de búsqueda: Quicksort, MergeSort, y HeapSort.

El Quicksort parte una lista en dos, tomando en cuenta un elemento como un valor

bandero; por ende, una lista tiene todos los elementos menores a dicha bandera, y la otra,

todos los elementos mayores. El MergeSort divide una lista en dos sublistas iguales y se

llama recursivamente para ordenar dichas sublistas. A continuación, junta ambas listas al

remover el elemento más pequeño de las sublistas y agregándolo a la lista final. Este

proceso es repetido hasta que una sublista este vacía cuando la otra sublista está agregada

a la lista final. El Heapsort crea un heap binary a partir de una lista de datos, y luego
P á g i n a 3 | 17
elimina el primero elemento de la lista y lo agrega al final de una lista final. Esto se repite

hasta que el heap esté vació.

La efectividad de los tres algoritmos de ordenamiento es de O (n log n). Sin

embargo, todos los algoritmos tienen sus ventajas y desventajas. Usualmente, el HeapSort

es el más lento, pero consume menos recursos al no ser recursivo. QuickSort usualmente

es el más rápido, especialmente en arreglos. MergeSort funciona mejor con listas

enlazadas.

P á g i n a 4 | 17
 Introducción

“Divide y Vencerás” es termino más reconocido en el mundo de las ciencias de la

computación o en ingles conocido como “Divide and conquer”. Esta frase ha sido

utilizada desde hace muchos años. Se le atribuye Divide y Vencerás a Julio Cesar (miliar

y político romano, nacido en el año 100 a.C.), porque los romanos para conquistar nuevas

tierras separaban a cada aldea vecina haciendo tratos e intercambios especiales con cada

uno de ellos, creando tensión y envidia entre cada una de las ciudades, así, evitando que

estas mismas juntaran fuerzas contra los Romanos, para asegurar la victoria.

Cuando visitas por primera vez una biblioteca para buscar específicamente un

libro, ¿Qué es lo primero que haces? La persona promedio se guiaría por el autor, el

género del libro o el titulo para encontrarlo fácilmente. Eso es el ejemplo más claro de

“Divide y Conquista”.

Este refrán desde la perspectiva algorítmica hace referencia a simplificar un

problema grande a un problema más pequeño, luego aún más pequeño y así

sucesivamente. El objetivo es tener los problemas o retos lo más simples posibles, para

resolverlos fácilmente. Esta técnica es famosa porque así es como los algoritmos de

ordenamiento funcionan de una manera eficiente.

Existen varios algoritmos del tipo Divide y Conquista, entre ellos tenemos: QuickSort,

MergeSort y HeapSort. A continuación, se realizará un análisis a profundidad de estos

tres algoritmos, tomando en consideración distintos factores como ser sus antecedentes

históricos, su efectividad y eficiencia, ventajas, desventajas, y demás para así poder emitir

un juicio objetivo y conocedor acerca de ellos una vez finalizada la investigación.

P á g i n a 5 | 17
 Marco Teórico

QuickSort:

Charles Antony Richard Hoare, es un científico británico, ganador del Premio

Turing en 1960, por sus aportes fundamentales a los lenguajes de programación. Su mayor

logro fue crear el QuickSort. Hoare trabajo en el Laboratorio Nacional de Física en el

Reino Unido, en un proyecto de traducción automática, un diccionario del ruso al inglés.

Ya que el QuickSort es uno de los algoritmos de ordenamiento de la categoría “Divide y

Conquista” se puede deducir que su orden asintótico es logarítmico. QuickSort nos ayuda

a ordenar n cantidad de elementos, de manera ascendente.

A continuación, un ejemplo de pseudocódigo que la página GeeksforGeeks ofrece

implementado el QuickSort:

/* low --> Starting index, high --> Ending index */

quickSort(arr[], low, high)

if (low < high)

/* pi is partitioning index, arr[pi] is now

at right place */

pi = partition(arr, low, high);

quickSort(arr, low, pi - 1); // Before pi

quickSort(arr, pi + 1, high); // After pi

}
P á g i n a 6 | 17
 }

QuickSort selecciona un elemento como bandera y divide la matriz dada alrededor de la

bandera seleccionada.

El proceso clave en QuickSort es la partición. El destino de las particiones es, dada una

matriz y un elemento x de la matriz como bandera, coloca x en su posición correcta en la

matriz ordenada y coloca todos los elementos más pequeños (más pequeños que x) antes

de x, y coloca todos los elementos mayores (mayores que x) después de X. Todo esto

debe hacerse en tiempo lineal. Así es como se logra de manera eficiente el ordenamiento

lógico. Hay otros tipos de algoritmos para ordenar n elementos, pero se ha comprobado

que el más eficiente siempre será el QuickSort.

MergeSort:

John Von Neumann se le reconoce como el inventor del algoritmo de ordenación

por mezcla, donde la primera y la segunda mitades de una matriz se ordenan de forma

recursiva, fusionándose luego. La diferencia entre Quick Sort, es que Merge Sort parte de

la idea que se necesitan menos pasos para construir una lista ordenada a partir de dos

listas también ordenadas, que a partir de dos listas desordenadas.

Según la página Ricardo Peña, hay una serie de pasos en la secuencia Merge Sort, a

continuación, se los presentaremos:

1. Ordenar una secuencia S de elementos:

1. Si S tiene uno o ningún elemento, está ordenada

2. Si S tiene al menos dos elementos se divide en dos secuencias S1 y S2, S1

conteniendo los primeros n/2, y S2 los restantes.

P á g i n a 7 | 17
 3. Ordenar S1 y S2, aplicando recursivamente este procedimiento.

4. Mezclar S1 y S2 ordenadamente en S

2. Mezclar dos secuencias ordenadas S1 y S2 en S:

1. Se tienen referencias al principio de cada una de las secuencias a mezclar

(S1 y S2).

2. Mientras en alguna secuencia queden elementos, se inserta en la secuencia

resultante (S) el menor de los elementos referenciados y se avanza esa referencia

una posición.

(PEÑA M., Ricardo. Diseño de programas. Formalismo y abstracción. Prentice-Hall, 1998.)

MergeSort siendo de la categoría “Divide y Vencerás”, se tarda un tiempo logarítmico.

MergeSort es ideal para listas enlazadas, ya que es más estable y cómodo para medios de

acceso lento como bibliotecas. (Tiene complejo de espacio incorrecto en las matrices

debido a requisitos de almacenamiento adicionales.)

El pseudocódigo que brinda GeeksforGeeks para MergeSort nos hace entender mejor

cómo funciona:

MergeSort (arr [], l, r)

If r > l

1. Find the middle point to divide the array into two halves:

middle m = (l+r) /2

2. Call mergeSort for first half:

Call mergeSort (arr, l, m)

P á g i n a 8 | 17
 3. Call mergeSort for second half:

Call mergeSort (arr, m+1, r)

4. Merge the two halves sorted in step 2 and 3:

Call merge (arr, l, m, r)

HeapSort
:
El algoritmo de ordenamiento HeapSort fue inventado por J. W. J. Williams, un

científico computacional canadiense, en 1964. Asimismo. también fue Williams quien

inventó la estructura de datos conocida como el “Heap” o el “Montículo”,

simultáneamente. En ese mismo año, R. W. Floyd, también un científico computacional,

publicó una versión mejorada del algoritmo, aplicando implementaciones a arreglos.

Al igual que los otros dos algoritmos de ordenamiento, la notación asintótica del

HeapSort es de O (n log n), siendo en el mejor de los casos O(n). A pesar de esto, el

HeapSort es moderadamente más despacio en práctica es la mayoría de las máquinas, en

comparación a un QuickSort bien implementado. Sin embargo, HeapSort tiene la ventaja

que, inclusive en el peor de sus casos, su tiempo de ejecución es bastante favorable.

La página web RosettaCode.org nos dice lo siguiente acerca del funcionamiento

del ordenamiento HeapSort:

Este algoritmo consiste en almacenar todos los elementos del vector a ordenar en un

montículo (heap), y luego extraer el nodo que queda como nodo raíz del montículo (cima)

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

una propiedad de los montículos, por la cual, la cima contiene siempre el menor elemento

(o el mayor, según se haya definido el montículo) de todos los almacenados en él. El

algoritmo, después de cada extracción, recoloca en el nodo raíz o cima, la última hoja

por la derecha del último nivel. Lo cual destruye la propiedad heap del árbol. Pero, a

P á g i n a 9 | 17
 continuación, realiza un proceso de "descenso" del número insertado de forma que se

elige a cada movimiento el mayor de sus dos hijos, con el que se intercambia. Este

intercambio, realizado sucesivamente "hunde" el nodo en el árbol restaurando la

propiedad montículo del árbol y dejando paso a la siguiente extracción del nodo raíz.

(2019)

Un ejemplo de pseudocódigo de cómo se implementaría el algoritmo de ordenamiento de

HeapSort sería:

function heapsort(array A[0..n]):

montículo M

integer i; // declaro variable i

for i = 0..n:

insertar_en_monticulo(M, A[i])

for i = 0..n:

A[i] = extraer_cima_del_monticulo(M)

return A

Siendo insertar_en_monticula la función de agregar un elemento al montículo y

extraer_cima_del_montinuclo la función ‘Pop’ del montículo.

P á g i n a 10 | 17
 Metodología

Para llevar a cabo la presente investigación se utilizó una serie de técnicas o procesos

apropiados para e objetivo último de dicho informe. Como base de la investigación, se

optó utilizar una metodología análisis-síntesis, tomando en consideración los siguientes

parámetros:

Análisis: Se tomaron todos los conceptos y se separaron, para poder estudiar cada uno de

ellos de manera independiente. Esto permitió la comprensión plena de los conceptos,

apreciando cada uno de sus distintas características y factores clave.

Síntesis: Comparamos todos los diferentes algoritmos estudiados en la etapa anterior,

buscando entre ellos concordancias y conexiones, buscando entender como estos

concordaban unos con otros y como se diferenciaban. Se logró entender sus similitudes y

aptitudes para distintos casos.

Clasificación: A partir de lo estudiado en las dos etapas anteriores, fue fácil clasificar

cada uno de los algoritmos según el caso o la implementación que más conviniera,

tomando en cuenta sus especificaciones y requerimientos particulares.

Conclusión: Las conclusiones del presente estudio serán presentadas al final del informe,

tomando en cuenta todo lo analizado y aprendido en las etapas anteriores de la

investigación.

P á g i n a 11 | 17
 Investigación Aplicada:

En la sección de investigación aplicada del informe se presentan ejemplos de los

siguientes algoritmos:

Algoritmo de Floyd: Un algoritmo diseñado para encontrar el camino más corto al

momento de recorrer un grafo, tomando en cuenta las distancias de todos los posibles

vértices al momento del recorrido.

Algoritmo de Prim: Encuentra un árbol de expansión mínimo para un gráfico no dirigido

ponderado. Esto significa que encuentra un subconjunto de los bordes que forma un árbol

que incluye cada vértice, donde se minimiza el peso total de todos los bordes del árbol.

El algoritmo opera construyendo este árbol un vértice a la vez, desde un vértice inicial

arbitrario, en cada paso agregando la conexión más barata posible del árbol a otro vértice.

Algoritmo de Dijkstra: El algoritmo de Dijkstra es muy similar al algoritmo de Prim para

el árbol de expansión mínimo. Al igual que MST de Prim, generamos un SPT (árbol de

ruta más corto) con una fuente dada como raíz. Mantenemos dos conjuntos, un conjunto

contiene vértices incluidos en el árbol de la ruta más corta, otro conjunto incluye vértices

que aún no están incluidos en el árbol de la ruta más corta. En cada paso del algoritmo,

encontramos un vértice que está en el otro conjunto (conjunto de aún no incluido) y tiene

una distancia mínima de la fuente.

Todos los ejemplos son presentados en el lenguaje de programación Java, citando las

fuentes respectivas de estos en la sección bibliográfica del presente.

P á g i n a 12 | 17
 Conclusiones y Recomendaciones

Los algoritmos mencionados a lo largo de la investigación fueron creados hace

varias décadas y desde entonces no se ha encontrado maneras más eficientes para el

ordenamiento de datos. Los grandes profesionales que trabajaron en ellas aún siguen

siendo reconocidos por ello. ¿Por que? Simplemente porque hasta el día hoy no hay

algoritmos que logren superarlas en tiempo de ejecución.

Quicksort particiona una lista en dos listas secundarias con todos los elementos

menos que un valor "bandera" en una lista y todos los elementos mayores que el valor

pivote en la otra, luego se llama a sí misma recursivamente para ordenar las listas

sublistas.

Mergesort divide una lista por igual en 2 listas secundarias y se llama a sí misma

recursivamente para clasificar las listas secundarias. Luego, "une" las 2 listas juntas,

eliminando el elemento más pequeño de las sublistas y agregándole a la lista final. Este

proceso se repite hasta que una lista secundaria está vacía cuando la otra lista se agrega a

la lista final.

Heapsort crea un heap binario de una lista de datos, luego elimina el primer

elemento de la lista y lo agrega a una lista final. Esto se repite hasta que el montón está

vacío.

Los tres tipos se ejecutan en tiempo O (n logn), aunque el ordenamiento dinámico

es probablemente el más lento. Sin embargo, heapsort es una ordenación no recursiva.

Por lo general, el ordenamiento rápido es más rápido en los arreglos, siempre que la

bandera se elija aleatoriamente, mientras que el orden de combinación funciona mejor en

las listas enlazadas.

P á g i n a 13 | 17
 En resumen, si, si recomendamos el uso de QuickSort, MergeSort y HeapSort.

Cada una de ellas tiene sus diferencias, donde un desarrollador sabe cual usar según el

escenario en que lo necesita. Quien conozca sus pequeñas diferencias, sabrá de qué

manera le será más útil.

P á g i n a 14 | 17
 Bibliografía

Fuentes para la investigación de algoritmos de ordenamiento:

Charles Antony Richard Hoare. (n.d.). Retrieved from

https://www.ecured.cu/Charles_Antony_Richard_Hoare

HeapSort. (2019, March 05). Retrieved from https://www.geeksforgeeks.org/heap-sort/

Historia. (n.d.). Retrieved from https://gsauceda1.wixsite.com/quicksort/historia

Merge Sort. (2018, October 31). Retrieved from https://www.geeksforgeeks.org/merge-sort/

MergeSort. (n.d.). Retrieved from https://www.ecured.cu/MergeSort

Nullxor. (n.d.). Algoritmo Heap Sort. Retrieved from

http://programagic.blogspot.com/2016/12/algoritmo-heap-sort.html?m=1

QuickSort. (n.d.). Retrieved from https://www.ecured.cu/QuickSort

Sorting algorithms/Heapsort. (n.d.). Retrieved from

http://rosettacode.org/wiki/Sorting_algorithms/Heapsort

Skiena, Steven (2008). "Searching and Sorting". The Algorithm Design Manual. Springer.

p. 109. doi:10.1007/978-1-84800-070-4_4. ISBN 978-1-84800-069-8. [H]eapsort is

nothing but an implementation of selection sort using the right data structure.

A. 2014,06. Ejemplo de Metodología de la investigación. Revista Ejemplode.com. Obtenido

06, 2014, de https://www.ejemplode.com/13-ciencia/3838-

ejemplo_de_metodologia_de_la_investigacion.html

P á g i n a 15 | 17
 Fuentes utilizadas para ejemplos de la investigación aplicada:

Algorithms. (2019). Prim's - Minimum Spanning Tree (MST) using Adjacency Matrix |

Algorithms. [online] Available at: https://algorithms.tutorialhorizon.com/prims-

minimum-spanning-tree-mst-using-adjacency-matrix/ [Accessed 26 Mar. 2019].

Algorithms. (2019). Prim's Algorithm - Minimum Spanning Tree (MST) | Algorithms.

[online] Available at: https://algorithms.tutorialhorizon.com/prims-algorithm-minimum-

spanning-tree-mst/ [Accessed 26 Mar. 2019].

GeeksforGeeks. (2019). Dijkstra's shortest path algorithm in Java using PriorityQueue -

GeeksforGeeks. [online] Available at: https://www.geeksforgeeks.org/dijkstras-shortest-

path-algorithm-in-java-using-priorityqueue/ [Accessed 26 Mar. 2019].

GeeksforGeeks. (2019). Dijsktra's algorithm. [online] Available at:

https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/

[Accessed 26 Mar. 2019].

GeeksforGeeks. (2019). Floyd Warshall Algorithm | DP-16 - GeeksforGeeks. [online]

Available at: https://www.geeksforgeeks.org/floyd-warshall-algorithm-dp-16/ [Accessed

26 Mar. 2019].

Márquez, R. (n.d.). La relación entre precio, calidad y los estándares internacionales....

[online] GestioPolis - Conocimiento en Negocios. Available at:

https://www.gestiopolis.com/relacion-precio-calidad-estandares-internacionales-

calidad/ [Accessed 20 Feb. 2019].

P á g i n a 16 | 17
Nanyastridcoral.blogspot.com. (2002). CONTROL DE CALIDAD DE ALIMENTOS.

[online] Available at: http://nanyastridcoral.blogspot.com/2011/01/control-de-calidad-

de-alimentos.html [Accessed 16 Feb. 2019].

Search.proquest.com. (2019). ProQuest. [online] Available at:

https://search.proquest.com/results/31C6BB974E554B3EPQ/1?accountid=35325

[Accessed 2 Mar. 2019].

P á g i n a 17 | 17