finish up the informe
This commit is contained in:
@@ -1,126 +1,81 @@
|
||||
entrada: array: arreglo de n datos: n: tamaño del arreglo
|
||||
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
|
||||
|
||||
funcion ordenamientobitonico(array, n)
|
||||
orden(array, n, 1)
|
||||
return array
|
||||
fin funcion
|
||||
|
||||
inicio funcion mejor_potencia_de_2_menos_a_n(inicio n)
|
||||
|
||||
inicio k = 1
|
||||
|
||||
mientras(k > 0 y k < n) hacer
|
||||
funcion potencia_de_dos(n)
|
||||
si n = 0 entonces
|
||||
retornar 0
|
||||
fin si
|
||||
mientras n distinto 1 hacer
|
||||
si n es modulo de 2 entonces
|
||||
retornar 0
|
||||
fin si
|
||||
fin mientras
|
||||
retornar 1
|
||||
fin funcion
|
||||
|
||||
funcion mejor_potencia_de_2_menos_a_n(n)
|
||||
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 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;
|
||||
|
||||
funcion comparar(i, j, dir, array)
|
||||
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
|
||||
|
||||
funcion unionbitonica(low, n, dir, array)
|
||||
si n > 1 entonces
|
||||
k = n / 2
|
||||
para i = low hasta i < low + k con paso i = i + 1
|
||||
comparar(i + k, di, array)
|
||||
fin para
|
||||
unionbitonica(low, k, dir, array)
|
||||
unionbitonica(low + k, k, dir, array)
|
||||
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)
|
||||
funcion unionbitonico2(low, n, dir, array)
|
||||
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, array)
|
||||
fin para
|
||||
ordenamientobitonico2(low, k, dir, array)
|
||||
ordenamientobitonico2(low + k, n - k, dir, array)
|
||||
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
|
||||
funcion recorrerbitonico(low, n, dir, array)
|
||||
si n > 1 entonces
|
||||
k = n / 2
|
||||
recorrerbitonico(low, k, 1, array)
|
||||
recorrerbitonico(low + k, k, 0, array)
|
||||
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
|
||||
funcion recorrerbitonico2(low, n, dir, array)
|
||||
si n > 1 entonces
|
||||
k = n / 2
|
||||
recorrerbitonico2(low, k, !di, array)
|
||||
recorrerbitonico2(low + k, n - k, dir, array)
|
||||
unionbitonico2(low, n, dir, array)
|
||||
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
|
||||
funcion orden(array, n, dir)
|
||||
si potencia_de_dos(n) entonces
|
||||
recorrerbitonico(0, n, dir, array)
|
||||
fin si
|
||||
sino
|
||||
recorrerbitonico2(0, n, dir, array)
|
||||
fin sino
|
||||
fin funcion
|
||||
|
||||
funcion ordenamientobitonico(inicio arreglo, inicio n)
|
||||
|
||||
orden(arreglo, n, 1)
|
||||
fin funcion
|
||||
@@ -1,13 +1,19 @@
|
||||
entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
|
||||
salida: arreglo array ordenado ascendentemente.
|
||||
salida: arreglo array ordenado ascendentemente
|
||||
|
||||
cuentaDeElementos := n
|
||||
repetir
|
||||
haCambiado := falso
|
||||
disminuir cuentaDeElementos
|
||||
repetir con indice desde 1 a cuentaDeElementos
|
||||
if (array en indice) > (array en (indice + 1))
|
||||
intercambiar (array en indice) con (array en (indice + 1))
|
||||
haCambiado := falso
|
||||
hasta haCambiado = verdad
|
||||
retorna array
|
||||
funcion bubblesort(array, n)
|
||||
flag = 1
|
||||
mientras que flag es verdad
|
||||
flag = false
|
||||
para i = 1 mientras que i < j con pasa i = i + 1 hacer
|
||||
si array[i] < array[i - 1] entonces
|
||||
temp = array[i]
|
||||
array[i] = array[i - 1]
|
||||
array[i - 1] = temp
|
||||
flag = verdad
|
||||
fin si
|
||||
fin para
|
||||
j = j - 1;
|
||||
fin mientras
|
||||
retorna array
|
||||
fin funcion
|
||||
|
||||
22
doc/pseudo/countingsort.txt
Normal file
22
doc/pseudo/countingsort.txt
Normal file
@@ -0,0 +1,22 @@
|
||||
entrada: array: arreglo de elementos enteros; n: tamaño del arreglo
|
||||
salida: arreglo array ordenado ascendentemente
|
||||
|
||||
funcion countingsort(array, n)
|
||||
para i = 0 mientras que i < n con paso i = i + 1 hacer
|
||||
count[i] = 0
|
||||
fin para
|
||||
para i = 0 mientras que i < n - 1 con paso i = i + 1 hacer
|
||||
para j = i + 1 mientras que j < n con paso j = j + 1 hacer
|
||||
si array[i] < array[j] entonces
|
||||
count[j] = count[j] + 1
|
||||
sino
|
||||
count[i] = count[i] + 1
|
||||
fin si
|
||||
fin para
|
||||
fin para
|
||||
|
||||
para i = 0 mientras que i < n con paso i = i + 1 hacer
|
||||
newarray[count[i]] = array[i]
|
||||
}
|
||||
retorna newarray
|
||||
fin funcion
|
||||
43
doc/pseudo/mergesort.txt
Normal file
43
doc/pseudo/mergesort.txt
Normal file
@@ -0,0 +1,43 @@
|
||||
entrada: array: arreglo de n datos; n: tamaño del arreglo
|
||||
salida: arreglo ordenado
|
||||
|
||||
funcion mergesort(array, n)
|
||||
correr_mergesort(array, 0, n - 1);
|
||||
retorna array
|
||||
fin funcion
|
||||
|
||||
funcion correr_mergesort(array, izquerda, derecha)
|
||||
si izquerda != derecha entonces
|
||||
medio = (izquerda + derecha) / 2
|
||||
correr_mergesort(array, izquerda, medio)
|
||||
correr_mergesort(array, medio + 1, derecha)
|
||||
unir(array, izquerda, medio + 1, derecha)
|
||||
fin si
|
||||
fin funcion
|
||||
|
||||
funcion unir(array, previo_izquerda, previo_medio, derecha)
|
||||
i = 0
|
||||
izquerda = previo_izquerda
|
||||
medio = previo_medio - 1
|
||||
far_derecha = derecha - izquerda + 1
|
||||
|
||||
mientras que previo_izquerda <= medio y previo_medio <= derecha hacer
|
||||
si array[previo_izquerda] < array[previo_medio] entonces
|
||||
temp[i++] = array[previo_izquerda++]
|
||||
sino
|
||||
temp[i++] = array[previo_medio++]
|
||||
fin si
|
||||
fin mientras
|
||||
|
||||
mientras que previo_izquerda <= medio hacer
|
||||
temp[i++] = array[previo_izquerda++]
|
||||
fin mientras
|
||||
|
||||
mientras que previo_medio <= derecha hacer
|
||||
temp[i++] = array[previo_medio++]
|
||||
fin mientras
|
||||
|
||||
para i = 0 mientras que i < far_derecha con paso i = i + 1 hacer
|
||||
array[izquerda + i] = temp[i]
|
||||
fin para
|
||||
fin funcion
|
||||
@@ -1,40 +1,33 @@
|
||||
entrada: array: arreglo de n datos: n: tamaño del arreglo
|
||||
entrada: array: arreglo de n datos; n: tamaño del array
|
||||
salida: arreglo ordenado
|
||||
|
||||
funcion quick_sort{
|
||||
|
||||
si(n < 2) entonces{
|
||||
retorna
|
||||
}
|
||||
funcion quick_sort(array, n)
|
||||
si n < 2 entonces
|
||||
retorna
|
||||
fin si
|
||||
|
||||
inicio i
|
||||
inicio j
|
||||
inicio temp
|
||||
inicio pivote
|
||||
pivote = array[n / 2]
|
||||
|
||||
pivote = arreglo[n / 2]
|
||||
para i = 0 y j = n - 1 con paso i = i + 1 y j = j - 1 hacer
|
||||
mientras que array[i] < pivote hacer
|
||||
i = i + 1
|
||||
fin mientras
|
||||
|
||||
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 que array[j] > pivote hacer
|
||||
j = j - 1
|
||||
fin mientras
|
||||
|
||||
mientras(arreglo[j] > pivote) hacer
|
||||
j = j - 1
|
||||
fin mientras
|
||||
si i >= j entonces
|
||||
break
|
||||
fin si
|
||||
|
||||
si(i >= j) entonces
|
||||
break
|
||||
fin si
|
||||
temp = array[i]
|
||||
array[i] = array[j]
|
||||
array[j] = temp
|
||||
fin para
|
||||
|
||||
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
|
||||
quick_sort(array, i)
|
||||
quick_sort(array + i, n - i)
|
||||
|
||||
fin funcion
|
||||
retorna array
|
||||
fin funcion
|
||||
|
||||
@@ -1,31 +1,17 @@
|
||||
entrada: array: arreglo de n datos: n: tamaño del arreglo
|
||||
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
|
||||
funcion selection_sort(array, n)
|
||||
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 array[j] < array[min_idx] entonces
|
||||
min_idx = j
|
||||
fin si
|
||||
fin para
|
||||
temp = array[min_idx]
|
||||
array[min_idx] = array[i]
|
||||
array[i] = temp
|
||||
fin para
|
||||
retorna array
|
||||
fin funcion
|
||||
|
||||
Reference in New Issue
Block a user