Benemérita Universidad Autónoma de Puebla

Facultad de Ciencias de la Computación

Algoritmos de ordenamiento – Proyecto 1

Análisis y Diseño de Algoritmos

Profesor: Irene Olaya Ayaquica

Alumno: Juan Ángel Gonzalez Flores
201655221
Introducción
Como vimos en la investigación anteriormente realizada, tenemos distintos tipos de algoritmos para el ordenamiento de datos,
ramificados en aquellos que son iterativos y aquellos recursivos. Sabemos que un algoritmo iterativo es mas ligero para para la maquina
que lo ejecuta, llevan mas tiempo de ejecución. Sin embargo, los algoritmos de tipo recursivo son mas eficaces y rapidos, pero esto
conlleva que el uso de memoria por estos algoritmos sea mas pesado para la maquina huésped.
En el siguiente proyecto se revisaran casos en los cuales los algoritmos implementados son de orden O = n 2, O = n(lonN), O = n. Se darán
casos especiales para medir cada uno de los casos en los cuales los algoritmos pueden caer, ya sea el mejor, peor y caso medio. Estos
serán comparados y bien podrá determinarse cuál de estos es el mejor. Para el caso donde O = n2 utilizaremos el algoritmo de Seleccion,
para O = nk (Lineal) utilizaremos Radix, y finalmente para O = n(lonN) utilizaremos el algoritmo de QuickSort, que es un algoritmo de
recursividad.
Las pruebas que realizaremos a cada algoritmo van desde los 10,000, 100,000, y 1,000,000 de datos. Para el mejor caso, daremos un array
donde datos ya se encuetren ordenados, para el caso medio daremos un array con números random, y finalmente para el peor caso
daremos los números de manera ascendente. Abra situaciones que dependiendo el numero de datos, la forma en la que vengan los datos
y el algoritmo dado, que este podrá comportarse de manera distinta.
Cuando implementemos estos algoritmos el tiempo ejecución podrá varian dese los 0.2 – 0.6 microsegundos hasta los 15 min. Pues bien,
veamos cómo se implementan.
Tabla de contenido
Introducción ................................................................................................................................................................................................................ 2
RESUMEN .................................................................................................................................................................................................................... 4
Mejor Caso .............................................................................................................................................................................................................. 7
Peor Caso................................................................................................................................................................................................................. 7
Caso Medio .............................................................................................................................................................................................................. 8
QuickSort ..................................................................................................................................................................................................................... 8
10,000 ..................................................................................................................................................................................................................... 9
100,000 ................................................................................................................................................................................................................... 9
1,000,000 ............................................................................................................................................................................................................... 10
Radix ......................................................................................................................................................................................................................... 10
10,000 ................................................................................................................................................................................................................... 10
100,000 ................................................................................................................................................................................................................. 11
1,000,000 ............................................................................................................................................................................................................... 11
Selección ................................................................................................................................................................................................................... 12
10,000 ................................................................................................................................................................................................................... 13
100,000 ................................................................................................................................................................................................................. 13
1,000,000 ............................................................................................................................................................................................................... 14
Conclusiones.............................................................................................................................................................................................................. 15
Referencias ................................................................................................................................................................................................................ 16
RESUMEN
Primero en java vamos a crear 2 clases, una de ellas contendrá todos los algoritmos y la otra tendrá el Main desde donde serán invocados
estos algoritmos.

Algoritmos_Pruebas.java contendrá a los algoritmos QuickSort, Radix, y Selección. Procederemos a comenzar por el algoritmo de
QuickSort.
Como observamos el algoritmo representa la recursividad en su máxima expresión, este método primeramente solo recibirá el array de
datos desordenamos, después de ahí se procederá a sacar un índice menor y mayor, de estos índices se obtendrá el pivote.

Utilizaremos estas dos variables que nos ayudaran a medir el tiempo de ejecución del algoritmo
Las variables fin e inicio de tipo long, nos ayudaran a medir el tiempo de ejecución del algoritmo, y finalmente la impresión de la variable
dif nos ayudara a imprimir el tiempo de ejecución. Sin embargo, la variable inicio debe ser declarada antes de hacer el llamado a la función,
y la variable fin después del finalizar función. Igualmente, antes de ser impreso este valor de tiempo, es convertido a segundos por la
multiplicación de 1.0e-9 por la diferencia de los valores de tiempo de las variables inicio y fin, y finalmente haciendo un cast a tipo doublé.

Mejor Caso
Para llenar el array en forma ascendente, usaremos la siguiente función en el main

Donde el array será llenado desde 0,1,2,3……..9,999.

Peor Caso

El array será llenado con la secuencia: 9,999, 9,998, 9,997……..3,2,1,0

Caso Medio

Aquí el array será llenado con datos al azar contenidos entre 0 hasta 9,999.00

QuickSort
Complejidad
Mejor caso: O(n·log n).
Caso Medio: O(n·log n).

Peor caso: O(n²)

Cada uno de los casos va a varidad según la cantidad de datos a ordenar, 10,000, 100,000, y 1,000,000 datos
10,000
No. de Datos Tiempo(s) Orden Caso Consola
10,000 0.0018 Ascendente Mejor

10,000 0.0037 Descendente Peor

10,000 0.0028 Aleatorio Medio

100,000
No. de Datos Tiempo(s) Orden Caso Consola
100,000 .069 Ascendente Mejor

100,000 0.802 Descendente Peor

100,000 0.0939 Aleatorio Medio

1,000,000
No. de Datos Tiempo(s) Orden Caso Consola
1000000 0.18 Ascendente Mejor

1000000 Descendente Peor

1000000 0.16 Aleatorio Medio

Radix
Complejidad
Mejor caso: O(kn)

Caso Medio: O(kn)

Peor caso: O(kn)

10,000
No. de Datos Tiempo(s) Orden Caso Consola
10,000 0.011 Ascendente Mejor
10,000 0.027 Descendente Peor

10,000 0.012 Aleatorio Medio

100,000
No. de Datos Tiempo(s) Orden Caso Consola
100,000 0.086 Ascendente Mejor

100,000 0.065 Descendente Peor

100,000 0.069 Aleatorio Medio

1,000,000
No. de Datos Tiempo(s) Orden Caso Consola
 1000000 0.243 Ascendente Mejor

1000000 0.259 Descendente Peor

1000000 0.33 Aleatorio Medio

Selección
Complejidad
Mejor caso: O(n2)
Caso Medio: O(n2)

Peor caso: O(n2)

10,000
No. de Datos Tiempo(s) Orden Caso Consola
10,000 0.039 Ascendente Mejor

10,000 0.077 Descendente Peor

10,000 0.072 Aleatorio Medio

100,000
No. de Datos Tiempo Orden Caso Consola
100,000 2.86 Ascendente Mejor

100,000 7.752 Descendente Peor

100,000 5.723 Aleatorio Medio

1,000,000
No. de Datos Tiempo(S) Orden Caso Consola
1000000 945.17 Ascendente Mejor

1000000 1159.64 Descendente Peor

1000000 574.56 Aleatorio Medio

Conclusiones
Como hemos observado existen distintos tipos de algoritmos que nos ofrecen ventajas sobre otros, claro está que dependiendo nuestros
requerimientos es como podremos obtener el mayor provecho de estos. Resulta curioso pensar que, entre mayor rapidez, el algoritmo
de ordenamiento se vuelve inversamente proporcional a nivel programación, haciéndolo más complicado según su efectividad. Resulto
muy evidente notar que el algoritmo de selección no es el mejor de todos, pues al tener un Orden de n2, su tiempo de ejecución se
prolonga de manera abrupta. Es una fracción de tiempo mas pequeña, los algoritmos de Radix y QuickSort terminaron sumamente rápido
en segundos, lo que Selección tardo en minutos.
Si bien se presentan 3 distintos casos, el mejor (El array ya esta ordenado), el peor (El array esta invertido), y el caso medio (números
aleatorios), con esto el algoritmo puede comportarse de manera muy distinta. Los algoritmos lineales, Radix, siempre presentaran una
similitud con sus resultados, sea está acorde a la cantidad de datos a utilizar. Los algoritmos nLogN son aquellos que presentan la
característica que al graficarlos, presentan un comportamiento logarítmico. Para finalizar tenemos a los algoritmos cuadráticos, que como
hemos notado, quizá no sean los mejores para ordenar grandes cantidades de datos
Con nuestros ejemplos aquí realizados; 10,000, 100,000, y 1,000,000 datos creamos una gran brecha, que denoto muchísimo la diferencia
de algunos algoritmos con otros. Aquí solo se eligieron 3 algoritmos, cada uno con su nivel de complejidad, pero existen muchos otros
algoritmos similares con similitudes en los grados de complejidad. Pero como se recalca, esto debe ser usado según las necesidades y
requerimientos que se tengan, de esta manera no se tiene una falta de recursos o un desperdicio de estos.
Referencias
Libros
Introduction to algorithms / Thomas H. Cormen...[etal.]. — 2nded.p. cm. Includes bibliographical references and index. ISBN 0-262-
03293-7 (hc. : alk. paper, MIT Press). —ISBN 0-07-013151-1 (McGraw-Hill)1.

La culpa es del programmer 1.0 Fundamentos de algoritmos y logicos/ Guerrero Conde, Héctor Enrique, Feb 16, 2010, No. Pag. 441,
ISBN: 9789584463593, Computers / Mathematical & Statistical Software

Enlaces

http://ict.udlap.mx/people/ingrid/Clases/IS211/Radix.html
http://lwh.free.fr/pages/algo/tri/tri_es.htm