This commit is contained in:
Rodolfo Cuevas 2018-11-21 18:25:34 -03:00
parent 89cd51e84c
commit ac6813725d
4 changed files with 242 additions and 3 deletions

View File

@ -70,35 +70,77 @@ Xavier Canales
\newpage \newpage
\subsection{Quick Sort} \subsection{Quick Sort}
\lstinputlisting{pseudo/quicksort.txt}
\newpage \newpage
\subsection{Bubble Sort} \subsection{Bubble Sort}
\lstinputlisting{pseudo/bubblesort.txt} \lstinputlisting{pseudo/bubblesort.txt}
\newpage \newpage
\subsection{Bitonic Sort} \subsection{Bitonic Sort}
\lstinputlisting{pseudo/bitonicsort.txt}
\newpage \newpage
\subsection{Ordenamiento por conteo} \subsection{Ordenamiento por conteo}
\newpage \newpage
\subsection{Ordenamiento por selección} \subsection{Ordenamiento por selección}
\lstinputlisting{pseudo/selectionsort.txt}
\newpage \newpage
\section{Resultados} \section{Resultados}
\subsection{Análisis temporal} \subsection{Análisis temporal}
\subsubsection{Merge Sort} \subsubsection{Merge Sort}
Caso Promedio: $ \Theta (n log n)) $ \\
$en.wikipedia.org/wiki/Merge_sort#Analysis$
Peor Caso: $ O(n log n) $ \\
Mejor Caso: $ \Omega (n log n)$ \\
\subsubsection{Quick Sort} \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
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.
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} \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
Peor Caso: $ O(n^2) $ \\
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} \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))$ \\
\subsubsection{Ordenamiento por conteo} \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
Peor Caso: $ O(n + k) $ \\
Mejor Caso: $ \Omega (n + k)$ \\
\subsubsection{Ordenamiento por selección} \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.
Peor Caso: $O(n^2)$ \\
Mejor Caso: $\Omega(n^2)$
\newpage \newpage
\subsection{Datos} \subsection{Datos}

126
doc/pseudo/bitonicsort.txt Normal file
View File

@ -0,0 +1,126 @@
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
fin funcion
inicio funcion mejor_potencia_de_2_menos_a_n(inicio n)
inicio 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 funcion
funcion comparar(inicio i, inicio j, inicio dir, inicio arreglo)
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
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)
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
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
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
fin funcion
funcion ordenamientobitonico(inicio arreglo, inicio n)
orden(arreglo, n, 1)
fin funcion

40
doc/pseudo/quicksort.txt Normal file
View File

@ -0,0 +1,40 @@
entrada: array: arreglo de n datos: n: tamaño del arreglo
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

View File

@ -0,0 +1,31 @@
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