Un poco de teoría [arrays]

[Krain]

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:

public 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:

public 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:

public 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:

public 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:

public 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:

public 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:

public 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:

public 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:

public 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] + " ");
}