Metodo de ordenamiento propio

Hola como algunos de uds saben existen multiples metodos de ordenar elementos ya sea de un arreglo o de otro tipo de objeto.

Presento mi propio metodo de ordenamiento que me vino a la mente en un chispaso hoy.

por ejemplo si tenemos esto:

ingreso = 5,7,15,0,2,1

de salida tendriamos esto

salida = 0,1,2,5,7,15

Para ello existe la burbuja,el de ciclos y muchos otros mas pero como me gusta generar contenido propio muestro el mio.

Consta de 2 clases para no marearlos con tanto codigo.

Clase Main.java

import java.util.Random;
/**
 *
 * @author JONATHAN
 */
public class Main {
    public static void main(String[] args) {
        // TODO code application logic here
        int[] arreglo_temp = null;
        arreglo_temp = Crear_lista(5);
        Libreria objeto = new Libreria();
        System.out.println("ORIGINAL : "+ objeto.Visualizar(arreglo_temp));
        System.out.println("ORDENADO : "+ objeto.Visualizar(objeto.ordenar(arreglo_temp)));
    }

    private static int[] Crear_lista(int n) {
        int[] arre = new int[n];
        Random generador = new Random();
        for (int i = 0; i < arre.length; i++) {
            arre[i] = generador.nextInt(10);
        }
        return arre;
    }
}

Hasta ahi simple verdad, cumplo con la regla de orientado a objetos, sin nada de complicaciones de codigo.

El metodo Crear_lista genera un array de elementos aleatorios,jejeje asi no parece predeterminado a nada.

Ahora pasemos a la clase Libreria.java es decir la que trabaja con el ordenamiento.

import java.util.ArrayList;
/**
 *
 * @author JONATHAN
 */
class Libreria {
    private int[] vector;
    private int elementos;

    public Libreria() {
    }
    //para imprimir el array de la forma / 0 / 1 / 2 / 3 / 4 /5

    public String Visualizar(int[] v) {
        String s = " / ";
        for (int i = 0; i < v.length; i++) {
            s += v[i] + " / ";
        }
        return s;
    }

    int[] ordenar(int[] v) {
        this.vector = v;
        elementos = vector.length;
        ArrayList uno = new ArrayList();
        for (int i = 0; i < elementos; i++)
        {
            uno.add(vector[i]);//Recorro el arreglo y agrego cada elemento al arraylist
        }
        for(int i=0;i
        {
            vector[i]=toEntero(uno.get(indice_Menor(uno)));//Asigno al arreglo
            //primitivo el elemento menor del arraylist
            uno.remove(toEntero(indice_Menor(uno)));
            //Proceso a eliminar dicho elemento del arraylist
            //Se ejecuta un bucle rescatando el menor elemento.
            //Asi ordenaria mi arreglo
        }
        return vector;
    }

    private int indice_Menor(ArrayList indice) {
        int b = 0;
        for (int i = 0; i < indice.size(); i++) {
            if (toEntero(indice.get(i)) < toEntero(indice.get(b))) {
                b = i;
            }
        }
        return b;
    }

    private int toEntero(Object get) {
        //los arraylist retornan objetos pero necesito trabajar con enteros
        //Simplemente convierto a entero un objeto cuando es llamada esta funcion
        return Integer.parseInt(get.toString());
    }

}

Hagamos un resumen existen los metodos:

• Visualizar(int[] v);
• ordenar(int[] v);
• indice_Menor(ArrayList indice);
• toEntero(Object get);

El metodo  Visualizar(int[] v) es solo para la presentacion de datos de modo que no aparescan todos juntos.

El metodo ordenar(int[] v) es para realizar el ordenamiento propiamente dicho.

El metodo indice_Menor(ArrayList indice) sirve para obtener el menor elemento de un arraylist y retorna su indice para procesarlo.

Finalmente como los arraylist trabajan con objetos necesito un convertidor porque lo que usare seran enteros, para ese caso esta toEntero(Object get) que me retornara como entero cualquier objeto enviado.

Espero les sirva es algo que se me ocurrio comenten y diganme que les parece.

Share: