From ac6813725d32670a0466c3bee8d3653b098ad31b Mon Sep 17 00:00:00 2001 From: Rodolfo Cuevas Date: Wed, 21 Nov 2018 18:25:34 -0300 Subject: [PATCH] lol --- doc/Informe.tex | 48 ++++++++++++- doc/pseudo/bitonicsort.txt | 126 +++++++++++++++++++++++++++++++++++ doc/pseudo/quicksort.txt | 40 +++++++++++ doc/pseudo/selectionsort.txt | 31 +++++++++ 4 files changed, 242 insertions(+), 3 deletions(-) create mode 100644 doc/pseudo/bitonicsort.txt create mode 100644 doc/pseudo/quicksort.txt create mode 100644 doc/pseudo/selectionsort.txt diff --git a/doc/Informe.tex b/doc/Informe.tex index aaa7ae4..16ab5af 100644 --- a/doc/Informe.tex +++ b/doc/Informe.tex @@ -70,35 +70,77 @@ Xavier Canales \newpage \subsection{Quick Sort} - +\lstinputlisting{pseudo/quicksort.txt} \newpage \subsection{Bubble Sort} \lstinputlisting{pseudo/bubblesort.txt} \newpage \subsection{Bitonic Sort} - +\lstinputlisting{pseudo/bitonicsort.txt} \newpage \subsection{Ordenamiento por conteo} \newpage \subsection{Ordenamiento por selección} - +\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) $ \\ + + +Mejor Caso: $ \Omega (n log n)$ \\ \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} +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} +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} +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} +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 \subsection{Datos} diff --git a/doc/pseudo/bitonicsort.txt b/doc/pseudo/bitonicsort.txt new file mode 100644 index 0000000..ec4468c --- /dev/null +++ b/doc/pseudo/bitonicsort.txt @@ -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 \ No newline at end of file diff --git a/doc/pseudo/quicksort.txt b/doc/pseudo/quicksort.txt new file mode 100644 index 0000000..38a4e27 --- /dev/null +++ b/doc/pseudo/quicksort.txt @@ -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 \ No newline at end of file diff --git a/doc/pseudo/selectionsort.txt b/doc/pseudo/selectionsort.txt new file mode 100644 index 0000000..22b79d3 --- /dev/null +++ b/doc/pseudo/selectionsort.txt @@ -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 \ No newline at end of file