lol
This commit is contained in:
parent
89cd51e84c
commit
ac6813725d
@ -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}
|
||||
|
||||
126
doc/pseudo/bitonicsort.txt
Normal file
126
doc/pseudo/bitonicsort.txt
Normal 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
40
doc/pseudo/quicksort.txt
Normal 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
|
||||
31
doc/pseudo/selectionsort.txt
Normal file
31
doc/pseudo/selectionsort.txt
Normal 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
|
||||
Loading…
Reference in New Issue
Block a user