Browse Source

finish up the informe

tags/1.0.0
Chris Cromer 9 months ago
parent
commit
f03fe103c8
Signed by: Chris Cromer <chris@cromer.cl> GPG Key ID: 39CC813FF3C8708A

+ 62
- 39
doc/Informe.tex View File

@@ -67,10 +67,12 @@ Xavier Canales
\pagenumbering{arabic}
\section{Pseudo código}
\subsection{Merge Sort}
\lstinputlisting{pseudo/mergesort.txt}

\newpage
\subsection{Quick Sort}
\lstinputlisting{pseudo/quicksort.txt}

\newpage
\subsection{Bubble Sort}
\lstinputlisting{pseudo/bubblesort.txt}
@@ -78,73 +80,82 @@ Xavier Canales
\newpage
\subsection{Bitonic Sort}
\lstinputlisting{pseudo/bitonicsort.txt}

\newpage
\subsection{Ordenamiento por conteo}
\subsection{Counting Sort}
\lstinputlisting{pseudo/countingsort.txt}

\newpage
\subsection{Ordenamiento por selección}
\subsection{Selection Sort}
\lstinputlisting{pseudo/selectionsort.txt}

\newpage
\section{Resultados}

\subsection{Análisis temporal}
\subsubsection{Merge Sort}
Caso Promedio: $ \Theta (n log n)) $ \\
en.wikipedia.org/wiki/Merge\_sort\#Analysis

Peor Caso: $ O(n log n) $ \\
\underline{Caso Promedio:} $ \Theta(n log n)) $ \\
El caso promedio de merge sort es lo mismo que su peor caso. \\

\underline{Peor Caso:} $ O(n log n) $ \\
En el peor de los casos, el merge sort hace aproximadamente un 39\% menos de comparaciones que el quick sort en su caso promedio. En términos de movimientos, la complejidad del peor de los casos de merge sort es $ O(n log n) $ la misma complejidad que el mejor de Quick sort, y el mejor de la clasificación de merge sort toma aproximadamente la mitad de las iteraciones que en el peor de los casos. \\

Mejor Caso: $ \Omega (n log n)$ \\
\underline{Mejor Caso:} $ \Omega(n log n)$ \\
En el caso mejor de merge sort, el merge sort funciona mejor cuando los datos son secuencial. \\

\subsubsection{Quick Sort}
Caso Promedio: $ \Theta (n(log n)) $ \\
El tiempo de ejecución que tendrá el algoritmo dependerá de como se realice la partición de el arreglo entrada, es decir, depende de la selección del pivote
\underline{Caso Promedio:} $ \Theta(n(log n)) $ \\
El tiempo de ejecución que tendrá el algoritmo dependerá de como se realice la partición de el arreglo entrada, es decir, depende de la selección del pivote. \\

Peor Caso: $ O(n^2) $ \\
El peor de los casos para el quicksort resultará cuando la elección del pivote sea el valor más pequeño del arreglo o el más grande de este mismo.
\underline{Peor Caso:} $ O(n^2) $ \\
El peor de los casos para el quick sort resultará cuando la elección del pivote sea el valor más pequeño del arreglo o el más grande de este mismo. \\

Mejor Caso: $ \Omega $(n log(n)) \\
Para obtener el mejor caso posible será cuando el pivote se encuentre exactamente al medio del arreglo, porque lo dividirá en dos obteniendo n/2 elementos en ambas divisiones del arreglo
\subsubsection{Bubble Sort}
Caso Promedio: $ \Theta (n^2)) $ \\
El caso promedio compara la complejidad temporal con el peor caso, donde n es el numero de valores a ordenar, esto es producto de la forma en la cual Bubble transporta los valores dentro de su ordenamiento
\underline{Mejor Caso:} $ \Omega(n log(n)) $ \\
Para obtener el mejor caso posible será cuando el pivote se encuentre exactamente al medio del arreglo, porque lo dividirá en dos obteniendo n/2 elementos en ambas divisiones del arreglo. \\

Peor Caso: $ O(n^2) $ \\
\subsubsection{Bubble Sort}
\underline{Caso Promedio:} $ \Theta(n^2)) $ \\
El caso promedio compara la complejidad temporal con el peor caso, donde n es el numero de valores a ordenar, esto es producto de la forma en la cual \textit{bubble} transporta los valores dentro de su ordenamiento. \\

\underline{Peor Caso:} $ O(n^2) $ \\
En el peor caso el arreglo a ordenar va a estar ordenado en forma descendente previamente. \\

Mejor Caso: $ \Omega (n)$ \\
El mejor caso para el Bubble sort será cuando el arreglo de entrada venga previamente ordenado de menor a mayor.
\underline{Mejor Caso:} $ \Omega(n)$ \\
El mejor caso para el bubble sort será cuando el arreglo de entrada venga previamente ordenado de menor a mayor. \\

\subsubsection{Bitonic Sort}
Caso Promedio: $\Theta(log^2(n))$ \\
El ordenamiento bitonico responde igual a todos los casos porque siempre antes de empezar a ordenarlos realiza las mismas comparaciones para dejarlos en la secuencia bitonica

Peor Caso: $O(log^2(n))$ \\

Mejor Caso: $\Omega(log^2(n))$ \\
\underline{Caso Promedio:} $\Theta(log^2(n))$ \\
El ordenamiento bitonico responde igual a todos los casos porque siempre antes de empezar a ordenarlos realiza las mismas comparaciones para dejarlos en la secuencia bitonica. \\

\subsubsection{Ordenamiento por conteo}
Caso Promedio: $ \Theta (n + k)) $ \\
La complejidad total es igual para todos los casos, porque el algoritmo usa sólo ciclos simples, sin recursividad o sub-funciones, va directamente al analisis
\underline{Peor Caso:} $ O(log^2(n)) $ \\
Su caso peor es lo mismo que su caso promedio. \\

Peor Caso: $ O(n + k) $ \\
\underline{Mejor Caso:} $ \Omega(log^2(n)) $ \\
Su caso mejor es lo mismo que su caso promedio. \\

\subsubsection{Counting Sort}
\underline{Caso Promedio:} $ \Theta(\frac{n^2}{2}) $ \\
La complejidad total es igual para todos los casos, porque el algoritmo usa sólo ciclos simples, sin recursividad o sub-funciones, va directamente al análisis. \\

Mejor Caso: $ \Omega (n + k)$ \\
\underline{Peor Caso:} $ O(\frac{n^2}{2}) $ \\
Su caso pero es lo mismo que su caso promedio. \\

\subsubsection{Ordenamiento por selección}
Caso Promedio: $\Theta(n^2)$ \\
El ordenamiento por selección no es un algoritmo de ordenamiento adaptable, realiza el mismo numero de comparaciones de elementos en el mejor caso, el caso promedio y el peor de los casos, esto se debe a que no utiliza el orden existente de las entradas de el arreglo para ordenar.
\underline{Mejor Caso:} $ \Omega(\frac{n^2}{2}) $ \\
Su caso mejor es lo mismo que su caso promedio. \\

Peor Caso: $O(n^2)$ \\
\subsubsection{Selection Sort}
\underline{Caso Promedio:} $ \Theta(n^2) $ \\
El ordenamiento por selección no es un algoritmo de ordenamiento adaptable, realiza el mismo numero de comparaciones de elementos en el mejor caso, el caso promedio y el peor de los casos, esto se debe a que no utiliza el orden existente de las entradas del arreglo para ordenar. \\

Mejor Caso: $\Omega(n^2)$
\underline{Peor Caso:} $ O(n^2) $ \\
Su caso peor es lo mismo que su caso promedio. \\

\underline{Mejor Caso:} $ \Omega(n^2) $ \\
Su caso mejor es lo mismo que su caso promedio. \\

\newpage
\subsection{Datos}
La siguiente tabla contiene los resultados de las pruebas de los 6 algoritmos medidos en segundos. Para las pruebas usábamos un computador que tiene un procesador AMD A12 con 4 núcleos de 2.7Ghz y 16GB de memoria RAM.
La siguiente tabla contiene los resultados de las pruebas de los 6 algoritmos medidos en segundos. Para las pruebas usábamos un computador que tiene 4 nucleos de 3.2GHz y 16GB de memoria RAM.
\begin{center}
\begin{tabular}{|c|c|c|c|c|c|c|}
\hline
@@ -156,11 +167,11 @@ La siguiente tabla contiene los resultados de las pruebas de los 6 algoritmos me
\hline
\rule[-1ex]{0pt}{3.5ex} 100.000 & 0.170[s] & 0.300[s] & 0.124[s] & 11.645[s] & 30.269[s] & 32.347[s] \\
\hline
\rule[-1ex]{0pt}{3.5ex} 1.000.000 & 0.173[s] & 0.304[s] & 1.405[s] & 1,262.000[s] & 3,026.900[s] & 3,234.700[s] \\
\rule[-1ex]{0pt}{3.5ex} 1.000.000 & 0.173[s] & 0.304[s] & 1.405[s] & 3,144.000[s] & 6,717.674[s] & 7,248.000[s] \\
\hline
\rule[-1ex]{0pt}{3.5ex} 5.000.000 & 2.000[s] & 1.577[s] & 7.421[s] & 31,550.000[s] & 75,672.500[s] & 80,867.500[s] \\
\rule[-1ex]{0pt}{3.5ex} 5.000.000 & 2.000[s] & 1.577[s] & 7.421[s] & 60,951.000[s] & 139,273.286[s] & 153,273.539[s] \\
\hline
\rule[-1ex]{0pt}{3.5ex} 10.000.000 & 2.400[s] & 3.236[s] & 18.365[s] & 126,200.000[s] & 302,690.000[s] & 323,470.000[s] \\
\rule[-1ex]{0pt}{3.5ex} 10.000.000 & 2.400[s] & 3.236[s] & 18.365[s] & 243,804.000[s] & 557,093.1440[s] & 613,094.156[s] \\
\hline
\end{tabular}
\end{center}
@@ -174,6 +185,18 @@ La siguiente tabla contiene los resultados de las pruebas de los 6 algoritmos me

\newpage
\section{Conclusiones}
Basados en los resultados obtenido podemos poner los algoritmos en orden de mas rápido a menos rápido en la siguiente forma:
\begin{itemize}
\setlength\itemsep{0.1em}
\item Quick Sort
\item Merge Sort
\item Bitonic Sort
\item Selection Sort
\item Counting Sort
\item Bubble Sort
\end{itemize}
Al final resulta que el mas rápido algoritmo de ordenamiento que probamos fue Quick Sort mientras que el mas lento fue el Bubble Sort.
Los resultados de tiempo de ejecución estaban de lo que esperábamos dado el complejidad de los algoritmos.

\end{document}


BIN
doc/graph.png View File


+ 62
- 107
doc/pseudo/bitonicsort.txt View File

@@ -1,126 +1,81 @@
entrada: array: arreglo de n datos: n: tamaño del arreglo
entrada: array: arreglo de n datos; n: tamaño del arreglo
salida: arreglo ordenado

funcion potencia_de_dos(inicio n)
si(n = 0) entonces

retornar 0

fin si
mientras(n distinto 1) hacer
si (n % 2 distinto 0) hacer

retornar 0

fin si
fin mientras

retornar 1

funcion ordenamientobitonico(array, n)
orden(array, n, 1)
return array
fin funcion

inicio funcion mejor_potencia_de_2_menos_a_n(inicio n)
inicio k = 1

mientras(k > 0 y k < n) hacer
funcion potencia_de_dos(n)
si n = 0 entonces
retornar 0
fin si
mientras n distinto 1 hacer
si n es modulo de 2 entonces
retornar 0
fin si
fin mientras
retornar 1
fin funcion

funcion mejor_potencia_de_2_menos_a_n(n)
k = 1
mientras k > 0 y k < n hacer
busca el numero potencia de dos mas proximo hacia abajo en n

fin mientras

retorna k
fin mientras
retorna k
fin funcion

funcion comparar(inicio i, inicio j, inicio dir, inicio arreglo)

temp = array[i];
array[i] = array[j];
array[j] = temp;

funcion comparar(i, j, dir, array)
temp = array[i]
array[i] = array[j]
array[j] = temp
fin funcion

funcion unionbitonica(inicio low, inicio n, inicio dir, inicio arreglo)

inicio i
inicio k

si(n > 1) entonces

k = n/2

para i = low hasta i < low + k con paso i = i+1

comparar(, i + k, di, arreglo)
fin para

unionbitonica(low, k, dir, arreglo)
unionbitonica(low + k, k, dir, arreglo)

fin si

funcion unionbitonica(low, n, dir, array)
si n > 1 entonces
k = n / 2
para i = low hasta i < low + k con paso i = i + 1
comparar(i + k, di, array)
fin para
unionbitonica(low, k, dir, array)
unionbitonica(low + k, k, dir, array)
fin si
fin funcion

funcion unionbitonico2(inicio low, inicio n, inicio dir, inicio arreglo)

inicio i
inicio k

si(n > 1) entonces

k = mejor_potencia_de_2_menos_a_n

para i = low hasta i < low + n - k con paso i = i + 1 hacer

comparar(i, i + k, dir, arreglo)

fin para

ordenamientobitonico2(low, k, dir, arreglo)
ordenamientobitonico2(low + k, n - k, dir, arreglo)
funcion unionbitonico2(low, n, dir, array)
si n > 1 entonces
k = mejor_potencia_de_2_menos_a_n
para i = low hasta i < low + n - k con paso i = i + 1 hacer
comparar(i, i + k, dir, array)
fin para
ordenamientobitonico2(low, k, dir, array)
ordenamientobitonico2(low + k, n - k, dir, array)
fin funcion

funcion recorrerbitonico(int low, int n, int dir, int arreglo)

inicio k
si(n > 1) entonces

k = n / 2
recorrerbitonico(low, k, 1, arreglo)
recorrerbitonico(low + k, k, 0, arreglo)
unionbitonica(low, n, dir, array)

fin si
funcion recorrerbitonico(low, n, dir, array)
si n > 1 entonces
k = n / 2
recorrerbitonico(low, k, 1, array)
recorrerbitonico(low + k, k, 0, array)
unionbitonica(low, n, dir, array)
fin si
fin funcion

funcion recorrerbitonico2(int low, int n, int dir, int arreglo)

inicio k

si(n > 1) entonces
k = n / 2
recorrerbitonico2(low, k, !di, arreglo)
recorrerbitonico2(low + k, n - k, dir, arreglo)
unionbitonico2(low, n, dir, arreglo)
fin si
funcion recorrerbitonico2(low, n, dir, array)
si n > 1 entonces
k = n / 2
recorrerbitonico2(low, k, !di, array)
recorrerbitonico2(low + k, n - k, dir, array)
unionbitonico2(low, n, dir, array)
fin si
fin funcion

funcion orden(int arreglo, int n, int dir)

si(potencia_de_dos(n)) entonces
recorrerbitonico(0,n,dir,arreglo)

fin si

sino
recorrerbitonico2(0, n, dir, arreglo)
fin sino
funcion orden(array, n, dir)
si potencia_de_dos(n) entonces
recorrerbitonico(0, n, dir, array)
fin si
sino
recorrerbitonico2(0, n, dir, array)
fin sino
fin funcion

funcion ordenamientobitonico(inicio arreglo, inicio n)

orden(arreglo, n, 1)
fin funcion

+ 17
- 11
doc/pseudo/bubblesort.txt View File

@@ -1,13 +1,19 @@
entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
salida: arreglo array ordenado ascendentemente.
salida: arreglo array ordenado ascendentemente

cuentaDeElementos := n
repetir
haCambiado := falso
disminuir cuentaDeElementos
repetir con indice desde 1 a cuentaDeElementos
if (array en indice) > (array en (indice + 1))
intercambiar (array en indice) con (array en (indice + 1))
haCambiado := falso
hasta haCambiado = verdad
retorna array
funcion bubblesort(array, n)
flag = 1
mientras que flag es verdad
flag = false
para i = 1 mientras que i < j con pasa i = i + 1 hacer
si array[i] < array[i - 1] entonces
temp = array[i]
array[i] = array[i - 1]
array[i - 1] = temp
flag = verdad
fin si
fin para
j = j - 1;
fin mientras
retorna array
fin funcion

+ 22
- 0
doc/pseudo/countingsort.txt View File

@@ -0,0 +1,22 @@
entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
salida: arreglo array ordenado ascendentemente

funcion countingsort(array, n)
para i = 0 mientras que i < n con paso i = i + 1 hacer
count[i] = 0
fin para
para i = 0 mientras que i < n - 1 con paso i = i + 1 hacer
para j = i + 1 mientras que j < n con paso j = j + 1 hacer
si array[i] < array[j] entonces
count[j] = count[j] + 1
sino
count[i] = count[i] + 1
fin si
fin para
fin para

para i = 0 mientras que i < n con paso i = i + 1 hacer
newarray[count[i]] = array[i]
}
retorna newarray
fin funcion

+ 43
- 0
doc/pseudo/mergesort.txt View File

@@ -0,0 +1,43 @@
entrada: array: arreglo de n datos; n: tamaño del arreglo
salida: arreglo ordenado

funcion mergesort(array, n)
correr_mergesort(array, 0, n - 1);
retorna array
fin funcion

funcion correr_mergesort(array, izquerda, derecha)
si izquerda != derecha entonces
medio = (izquerda + derecha) / 2
correr_mergesort(array, izquerda, medio)
correr_mergesort(array, medio + 1, derecha)
unir(array, izquerda, medio + 1, derecha)
fin si
fin funcion

funcion unir(array, previo_izquerda, previo_medio, derecha)
i = 0
izquerda = previo_izquerda
medio = previo_medio - 1
far_derecha = derecha - izquerda + 1

mientras que previo_izquerda <= medio y previo_medio <= derecha hacer
si array[previo_izquerda] < array[previo_medio] entonces
temp[i++] = array[previo_izquerda++]
sino
temp[i++] = array[previo_medio++]
fin si
fin mientras

mientras que previo_izquerda <= medio hacer
temp[i++] = array[previo_izquerda++]
fin mientras

mientras que previo_medio <= derecha hacer
temp[i++] = array[previo_medio++]
fin mientras

para i = 0 mientras que i < far_derecha con paso i = i + 1 hacer
array[izquerda + i] = temp[i]
fin para
fin funcion

+ 31
- 38
doc/pseudo/quicksort.txt View File

@@ -1,40 +1,33 @@
entrada: array: arreglo de n datos: n: tamaño del arreglo
entrada: array: arreglo de n datos; n: tamaño del array
salida: arreglo ordenado

funcion quick_sort{
si(n < 2) entonces{
retorna
}

inicio i
inicio j
inicio temp
inicio pivote

pivote = arreglo[n / 2]

para i = 0 y j = n-1 con paso i = i + 1 y j = j - 1 hacer
mientras(arreglo[i] < pivote) hacer
i = i + 1
fin mientras

mientras(arreglo[j] > pivote) hacer
j = j - 1
fin mientras

si(i >= j) entonces
break
fin si

temp = arreglo[i]
arreglo[i] = arreglo[j]
arreglo[j] = temp
fin para
quick_sort(arreglo, i)
quick_sort(arreglo + i, n - i)
retorna el arreglo ordenado

fin funcion
funcion quick_sort(array, n)
si n < 2 entonces
retorna
fin si

pivote = array[n / 2]

para i = 0 y j = n - 1 con paso i = i + 1 y j = j - 1 hacer
mientras que array[i] < pivote hacer
i = i + 1
fin mientras

mientras que array[j] > pivote hacer
j = j - 1
fin mientras

si i >= j entonces
break
fin si

temp = array[i]
array[i] = array[j]
array[j] = temp
fin para

quick_sort(array, i)
quick_sort(array + i, n - i)

retorna array
fin funcion

+ 15
- 29
doc/pseudo/selectionsort.txt View File

@@ -1,31 +1,17 @@
entrada: array: arreglo de n datos: n: tamaño del arreglo
entrada: array: arreglo de n datos; n: tamaño del arreglo
salida: arreglo ordenado

funcion selection_sort
inicio i
inicio j
inicio temp
inicio min_idx

para i = 0 hasta i < n - 1 con paso i = i + 1 hacer

min_idx = i

para j = i + 1 hasta j < n con paso j = j + 1 hacer

si (arreglo[j] < arreglo[min_idx] hacer) hacer

min_idx = j
fin si
fin para

temp = arreglo[min_idx]
arreglo[min_idx] = arreglo[i]
arreglo[i] = temp

fin para

fin funcion
funcion selection_sort(array, n)
para i = 0 hasta i < n - 1 con paso i = i + 1 hacer
min_idx = i
para j = i + 1 hasta j < n con paso j = j + 1 hacer
si array[j] < array[min_idx] entonces
min_idx = j
fin si
fin para
temp = array[min_idx]
array[min_idx] = array[i]
array[i] = temp
fin para
retorna array
fin funcion

+ 0
- 41
doc/resultados.txt View File

@@ -1,41 +0,0 @@
Quick sort
10.000 - 0.1 segundos
100.000 - 0.17 segundos
1.000.000 - 0.173 segundos
5.000.000 - 2.0 segundos
10.000.000 - 2.4 segundos

Merge sort
10.000 - 0.28 segundos
100.000 - 0.30 segundos
1.000.000 - 0.304 segundos
5.000.000 - 1.577 segundos
10.000.000 - 3.236 segundos

Bitonic sort
10.000 - 0.09 segundos
100.000 - 0.124 segundos
1.000.000 - 1.405 segundos
5.000.000 - 7.421 segundos
10.000.000 - 18.365 segundos

Selection sort
10.000 - 0.143 segundos
100.000 - 11.645 segundos
1.000.000 - 21 minutos y 2.0 segundos 1262 segundos
5.000.000 - 8 horas, 45 minutos y 50 segundos teo 31550 segundos
10.000.000 - 1 day, 11 horas, 3 minutos y 20 segundos teo 126200 segundos

Count sort
10.000 - 0.258 segundos
100.000 - 30.269 segundos
1.000.000 - 50 minutos y 26.9 segundos teo 3026.9 segundos
5.000.000 - 21 horas, 1 minuto y 12.5 segundos teo 75672.5 segundos
10.000.000 - 3 dias, 12 horas, 4 minutos y 50 segundos teo 302690 segundos

Bubble sort
10.000 - 0.326 segundos
100.000 - 32.347 segundos
1.000.000 - 53 minutos y 54.7 segundos teo 3234.7 segundos
5.000.000 - 22 horas, 27 minutos y 47.5 segundos teo 80867.5 segundos
10.000.000 - 3 dias, 17 horas, 51 minutos y 10 segundos teo 323470 segundos

Loading…
Cancel
Save