Algoritmos de ordenación Java

Ordenamiento por Inserción:
 
 
 
Lo que hace este algoritmo es ir recorriendo de izquierda a derecha, posición por posición, revisando que en la sucesión estén en orden. Es decir por criterio, el numero consecutivo debe ser mayor, que el anterior, por tanto al analizar el número actual, al no ser mayor al anterior, se lo ubicara en la posicion correcta, así se lo ira comparando con todos sus anteriores, para determinar su posición correcta y corregirlo.
 
 
 

 
 
 
Ordenamiento por selección:
 
 
 
Lo que hace es recorrer el arreglo, con el objetivo de encontrar el menor numero de la sucesión y ubicarlo, en la posición inicial de arreglo, es decir en la primera posición.
Luego recorrería nuevamente al arreglo, pero en la posición siguiente, es decir sin contar la primera posición. Cuando se encuentre el numero menor en ese internvalo, se lo colocara en la posición siguiente al primero y así sucesivamente.
 
 
 

 
 
 
 
 
Ordenamiento Shell sort
 
 
 
Este método consiste, inicialmente divivir la cantidad de elementos que tiene el arreglo por 2. Luego con el cociente( C ) obtenido, se procede a juntar grupos de C+1, por ejemplo si tenemos 123456, C=3. Los grupos inicial sería 1234. De esta manera, con ese grupo se compara el primer elemento con el ultimo, en caso que el ultimo sea menor se cambias de lugares. Luego, se toma el grupo desde la segunda posición, hasta la posición +C y se vuelve a comparar. Cuando se llega al tope es decir, cuando no es posible armar el grupo de C+1, se procede hacer una maniobra parecida al método burbuja, solo que no se compara con el consecutivo, sino con el siguiente.
Que consiste en tomar el primer y el tercero elemento, para determina si se debe cambiar de lugar. Luego se hace lo mismo con la posición 2 y la posición 4, luego vendría la posición 3, con la 5, pero aquí comienza a realizarse la doble comparación.
Es decir la posición 3 se compara con la 5, y si la el elemento 5 es menor, se procede a colocar el elemento 3 al 5 y luego el elemento cinco se compara, con el elemento que esta un salto de la posición 3, pero hacia atrás, es decir la posición 1.
Cuando mas, alejado, mas comparaciones se hacen hacia atrás.
Video.
 
 

 
 
 
Ordenamiento de Burbuja.(Bubble Sort)
 
 
 
El método se basa en tomar un par de números, no cualquiera, sino que sean adyacentes y además, se comienzan a analizar desde la posición 1.
Entonces al evaluar ese par, quizás haga falta modificar la posición de ambos, dependiendo quien de ellos es mayor. Cuando se realiza el proceso de intercambios o no, se procede a realizar a realizar lo mismo, con la diferencia en que se tomaría la posición 2y3 para realizar la misma operación, luego 3y4 y asi sucesivamente. Hasta no poder hacer mas comparaciones. Sin embargo al realizar una sola pasada, no termina por ordenar el arreglo. Por tanto se realiza varias veces la operación, hasta que este ordenado.
Básicamente el proceso, consta de eso, sin embargo se suelen realizar esta operación de una manera mas inteligente, de modo que no se hagan operaciones inncesarias.
Por ejemplo, si tenemos esta sucesión 1234587. No tendría sentido realizar el burbujeo en todo esa sucesión nuevamente, solamente haría falta en la posición 8y7 cambiar.
 

 



 
Ordenamiento por Mezcla (MergeSort)
 
 
 
Es un método que se basa en la técnica divide y venceras(Divide and conquer)
Que consiste, inicialmente en dividir el arreglo por la mitad, dejando ambos lados dos partes iguales, o a sumo, q se diferencia de un elemento.
Al conseguir esas dos partes, se volverá a dividir, ambas sucesivamente, hasta tener uno solo. Luego al terminar, se comienza a comparar, y cocoloar nuevamente en grupo de 2, 4, y mas así. Hasta tener el array completo, sin dividir.
 
 
 

 
 
 
Ordenamiento rápido(QuickSort)
 
 
 

 

 
 
 
Se tienen 3 punteros, uno del lado izquierdo y otro del lado derecho(extremos)
Un puntero, llamado pibote, que puede ser cualquiera.
Con el será ira comporando, con los elementos, de los punteros restantantes(izq y der)
El pibote, lo que hace es ubicar a su derecha o a su izq los valores que apuntan punteros.
 
 
Metodo QuickSort hecho por mi. Uso menos while para reducir la complejidad.
import java.lang.reflect.Array;


public class p {

    /**
     * @param args
     */
    public static void main(String[] args) {
        int[] a = {5,11,7,15,4,12,4,75,1,3,5,7,6,23,3,4,2,1,45,13};
       
        ordenar(a,0,a.length-1);
       
        System.out.println(a[0]+" "+a[1]+" "+a[2]+" "+a[3]+" "+a[4]+" "+a[5]+" "+a[6]+" "+a[7]+" "+a[8]+" "+a[9]+" "+a[10]+" "+a[11]+" "+a[12]+" "+a[13]+" "+a[14]+" "+a[15]+" "+a[16]+" "+a[17]+" "+a[18]+" "+a[19]);
       
       

    }

    public static void ordenar(int[] a, int extizq, int extder){
        int extremoder=extder;
        int extremoizq=extizq;
        int pibote=a[extizq];
        boolean ladoder=true;
        boolean ladoizq=false;
        if(extder==extizq || extder<0 || extizq<0){
         return;   
        }
       
        while(extremoder!=extremoizq){
           
                    if(a[extremoder]<pibote &&ladoder==true){
                        a[extremoizq]=a[extremoder];
                        extremoizq++;
                        ladoder=false;
                        ladoizq=true;
                        //ordenar(a,++extremoizq,extremoder);
           
                       
                    }
                    if(ladoder==true){
                    extremoder--;
                    }
                    if(ladoizq==true){
                    while(extremoder!=extremoizq){
                        if(a[extremoizq]>pibote){
                            a[extremoder]=a[extremoizq];
                            extremoder--;
                            ladoder=true;
                            ladoizq=false;
                            break;
                            //ordenar(a,extremoizq,--extremoder);
                        }
                        else{
                            extremoizq++;
                           
                        }
                        }
                    }
       
        }
       
       
       
        a[extremoder]=pibote;
        if((extremoder-1)-extizq>0){
        ordenar(a,extizq,extremoder-1);
        }
        if(extder-(extremoder+1)>0){
        ordenar(a,extremoder+1,extder);
        }
       
       
       
       
        }
       
       
       
}
   



Los algoritmos no son dificiles de ingeniarselas, si agarran lapiz y papel, pensando como hacerlo, les va a salir. Solo es usar ciclos, y variables auxiliares.
En cuanto al quicksort y mergesort son algoritmos recursivos, por lo tanto tendran que pensar un poco mas, sobre todo el caso base.
La idea de la recursión es que cada vez que llamamos al mismo metodo, sera con instancias mas chicas, de la que ingresamos inicialmente(parametro del metodo). Es decir si ingresamos un vector de 100 elementos, se supondria que al volver a llamar al mismo metodo, se ingresarias un vector mas chico. Recursivamente, llegara a un tope, q en este caso sería que si tiene un elemento por poner algo, devuelve 1.
Si lo quieren hacer en algún IDE e ir tanteando como hacerlo, capaz que les salga, pero van a tardar mas en hacerlo. Creo que los mas recomendable es usar lapiz y papel.



Si no quieren pensar mucho acá esta la pagina donde tienen los métodos escritos. Pero acuerdense que si alguien les pide hacer algo especificio, dudo que en google este para ayudarnos
-->
 http://enrrike87.blogspot.com.ar/2011/06/metodos-de-ordenamiento-java_21.html

Saludos.
Algoritmos de ordenación Java
10 Puntos Score: 1.7/10
Visitas: 1859 Favoritos: 11
Ver los usuarios que votaron...
5 Comentarios Algoritmos de ordenación Java
Mira vos...hubiera servido en la carrera de ingenieria hace un par de a?
Sencillo pero Creo que es uno de los Mejores Aportes de Identi
Muy buen aporte.
gracias por compartirlo  
Para dejar un comentario Registrate! o.. eres ya usuario? Accede!