lol

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}

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

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

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