Hola foreros, ahora os traigo un poco de teoría sobre ordenamiento de arrays, yo aquí solo pongo unos pocos métodos de ordenación.
Bueno, antes de empezar con los ordenamientos pondré rápidamente unos métodos sencillos para búsqueda de valores.
Buscar mayor elemento y su posición en el array.
Código Java:
Ver originalpublic void mayorElemento()
{
int pos = 0;
int mayor = array[0];
for(int i = 1; i < array.length; i++)
{
if (array[i] > mayor)
{
mayor = array[i];
pos = i;
}
}
}
Buscar menor elemento y su posición en el array.
Código Java:
Ver originalpublic void menorElemento()
{
int pos = 0;
int menor = array[0];
for(int i = 1; i < array.length; i++)
{
if (array[i] < menor)
{
menor = array[i];
pos = i;
}
}
}
Calcular la media del array y ver cuantos valores hay mayores y menores.
Código Java:
Ver originalpublic void media()
{
float media = 0;
int mayor = 0;
int menor = 0;
for(int i = 0; i < array.length; i++)
{
media = media + array[i];
}
media = media / array.length;
for(int i = 0; i < array.length; i++)
{
if (array[i] >= media)
{
mayor++;
}
else
{
menor++;
}
}
System.
out.
println("Media del array:" + media
); System.
out.
println("Elementos mayores o iguales a la media: " + mayor
); System.
out.
println("Elementos menores a la media: " + menor
); }
Ahora si los ordenamientos
Ordenamiento de tipo burbuja (Bubblesort)
Código Java:
Ver originalpublic void ordenamientoBurbuja()
{
int array[] = {7,2,0,9,8,1,3,5,6,4};
for(int i = 0; i < array.length; i++)
{
for (int j = i+1; j < array.length; j++)
{
if(array[j] < array[i])
{
int aux = array[i];
array[i] = array[j];
array[j] = aux;
}
}
}
}
Ordenamiento de burbuja bidireccional (bidirectional bubble sort o Cocktail sort)
Código Java:
Ver originalpublic void cocktailSort()
{
int izquierda;
int derecha;
int ultimo = array.length;
do
{
for(int i = array.length -1; i > 0; i--)
{
if(array[i-1] > array[i])
{
int aux = array[i];
array[i] = array[i-1];
array[i-1] = aux;
ultimo = i;
}
}
izquierda = ultimo +1;
for(int j = 1; j < array.length; j++)
{
if(array[j-1] > array[j])
{
int aux = array[j];
array[j] = array[j-1];
array[j-1] = aux;
ultimo = j;
}
}
derecha = ultimo -1;
}
while(derecha >= izquierda);
}
Ordenamiento por insercción (Insertion sort)
Código Java:
Ver originalpublic void ordenamientoInserccion()
{
int aux;
for (int i = 0; i < array.length; i++)
{
aux = array[i];
for (int j = i-1; j >= 0 && aux < array[j]; j--)
{
array[j+1] = array[j];
array[j] = aux;
}
}
}
Ordenamiento por selección (Selection sort)
Código Java:
Ver originalpublic void ordenamientoSeleccion()
{
for (int i = 0; i < array.length; i++)
{
int valorMinimo = array[i];
int indexMinimo = i;
for (int j = i+1; j < array.length; j++)
{
if (valorMinimo > array[j])
{
valorMinimo = array[j];
indexMinimo = j;
}
}
array[indexMinimo] = array[i];
array[i] = valorMinimo;
}
}
Ordenamiento shell (Shell sort)
Código Java:
Ver originalpublic void ordenamientoShell()
{
int incremento = array.length;
do
{
incremento = incremento / 2;
for (int i = 0; i < incremento; i++)
{
for (int j = incremento+i; j < array.length; j += incremento)
{
int k = j;
while (k - incremento >= 0 && array[k] < array[k - incremento])
{
int aux = array[k];
array[k] = array[k - incremento];
array[k - incremento] = aux;
k -= incremento;
}
}
}
}
while (incremento > 1);
}
Ordenamiento rápido (Quicksort)
Código Java:
Ver originalpublic static void quicksort(int array[], int izquierda, int derecha)
{
int pivote = array[izquierda];
int i = izquierda;
int j = derecha;
int aux;
while(i < j)
{
while(array[i] <= pivote && i < j)
i++;
while(array[j] > pivote)
j--;
if (i < j)
{
aux = array[i];
array[i] = array[j];
array[j] = aux;
}
}
array[izquierda] = array[j];
array[j] = pivote;
if(izquierda < j-1)
quicksort(array, izquierda, j-1);
if(j+1 < derecha)
quicksort(array, j+1, derecha);
}
public static void main
(String[]args
) {
quicksort(array,0,array.length -1);
for(int i = 0; i < array.length; i++)
System.
out.
print(array
[i
] + " "); }