Ordenamiento por selección en Java

Cuando comienzas a programar, uno de los problemas más comunes y educativos que encontrarás es cómo ordenar una lista de elementos. Existen muchos algoritmos para lograrlo, cada uno con sus propias ventajas y desventajas. Uno de los más sencillos de entender e implementar es el Ordenamiento por Selección (o Selection Sort).

¿Cómo Funciona el Ordenamiento por Selección?

La idea detrás del Ordenamiento por Selección es bastante intuitiva y se asemeja a cómo una persona podría ordenar una baraja de cartas. El algoritmo divide la lista en dos partes: una parte ordenada (que al principio está vacía) y una parte desordenada (que al principio es toda la lista).

El proceso es el siguiente:

1. Encuentra el mínimo: Recorre la parte desordenada de la lista para encontrar el elemento más pequeño.
2. Intercambia: Coloca ese elemento al final de la parte ordenada. Esto se logra intercambiándolo con el primer elemento de la parte desordenada.
3. Avanza: La parte ordenada ahora tiene un elemento más. Repite los pasos 1 y 2 con la parte desordenada restante, que ahora es más pequeña.
4. Repite hasta que no queden elementos en la parte desordenada.

Visualmente, en cada paso, «seleccionamos» el elemento más pequeño y lo movemos a su posición correcta.

Implementación en Java

Ahora, veamos cómo se traduce esta lógica a código en Java. Crearemos una clase con un método que recibe un arreglo de números enteros y lo ordena.

import java.util.Arrays;

public class OrdenamientoSeleccion {

    // Método que ordena un arreglo usando el algoritmo de Selección
    void ordenar(int[] arreglo) {
        int tamano = arreglo.length;

        // Bucle principal que recorre todo el arreglo
        // Este bucle mueve el límite entre la parte ordenada y la desordenada
        for (int i = 0; i < tamano - 1; i++) {
            
            // Suponemos que el primer elemento de la parte desordenada es el mínimo
            int indiceMinimo = i;

            // Bucle para encontrar el índice del elemento más pequeño
            // en la parte restante del arreglo (la parte desordenada)
            for (int j = i + 1; j < tamano; j++) {
                if (arreglo[j] < arreglo[indiceMinimo]) {
                    // Si encontramos un elemento más pequeño, actualizamos el índice del mínimo
                    indiceMinimo = j;
                }
            }

            // Una vez encontrado el mínimo, lo intercambiamos con el primer
            // elemento de la parte desordenada (la posición 'i')
            int temporal = arreglo[indiceMinimo];
            arreglo[indiceMinimo] = arreglo[i];
            arreglo[i] = temporal;
        }
    }

    // Método principal para probar el algoritmo
    public static void main(String[] args) {
        // Creamos una instancia de nuestra clase
        OrdenamientoSeleccion ordenador = new OrdenamientoSeleccion();
        
        // El arreglo de números que queremos ordenar
        int[] miArreglo = {64, 25, 12, 22, 11};

        System.out.println("Arreglo original: " + Arrays.toString(miArreglo));

        // Llamamos al método para ordenar el arreglo
        ordenador.ordenar(miArreglo);

        System.out.println("Arreglo ordenado: " + Arrays.toString(miArreglo));
    }
}

Explicación del Código:

• El primer bucle for (con la variable i) se encarga de recorrer las posiciones del arreglo. La variable i actúa como el límite que separa la parte ya ordenada de la que aún falta por ordenar.
• Dentro de ese bucle, la variable indiceMinimo guarda la posición del número más pequeño que hemos encontrado hasta el momento en la parte desordenada.
• El segundo bucle for (con la variable j) es el que realmente busca el elemento más pequeño en la parte desordenada del arreglo.
• Finalmente, después de encontrar el índice del mínimo, intercambiamos los valores. Usamos una variable temporal para no perder el valor que estamos reemplazando.

Conclusión

El Ordenamiento por Selección es un algoritmo excelente para aprender los fundamentos de los algoritmos de ordenamiento debido a su simplicidad.

• Ventaja: Es muy fácil de entender y de implementar.
• Desventaja: No es muy eficiente para listas grandes. Su rendimiento no es bueno en comparación con algoritmos más avanzados como Quicksort o Merge Sort.

A pesar de su ineficiencia, es una herramienta de aprendizaje fantástica que te ayudará a construir una base sólida para entender algoritmos más complejos en el futuro.