lol

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