Resumen: implementar algoritmo del ordenamiento de burbuja en Java para ordenar un arreglo usando el método de la burbuja.

Vamos a ver cómo aplicar el método de burbuja a arreglos de tipo numérico (int) como a arreglos de tipo cadena (String).

Método de la burbuja en Java

Este método utiliza ciclos anidados. En el primero, simplemente recorremos todo el arreglo. En el segundo, recorremos desde el índice 0 hasta la longitud - 2.

Dentro del segundo ciclo comparamos el elemento actual con el siguiente (por eso solo llegamos hasta longitud – 2 para evitar acceder a un elemento más allá de los límites del arreglo en la última iteración) y en caso de que el actual sea mayor que el siguiente, intercambiamos.

Para intercambiar podemos implementar una variable temporal o cualquier otro método; eso sí, debemos modificar directamente al arreglo.

Función del método burbuja en Java

Veamos el método. Queda definido así:

private static void burbuja(int[] arreglo) {
    for (int x = 0; x < arreglo.length; x++) {
        // Aquí "y" se detiene antes de llegar
        // a length - 1 porque dentro del for, accedemos
        // al siguiente elemento con el índice actual + 1
        for (int y = 0; y < arreglo.length - 1; y++) {
            int elementoActual = arreglo[y],
                    elementoSiguiente = arreglo[y + 1];
            if (elementoActual > elementoSiguiente) {
                // Intercambiar
                arreglo[y] = elementoSiguiente;
                arreglo[y + 1] = elementoActual;
            }
        }
    }
}

Es una función que recibe un arreglo de enteros. En mi caso no necesito una variable temporal pues antes de hacer el intercambio, la variable elementoActual y elementoSiguiente tienen los valores originales.

Después, si es necesario, en la línea 11 y 12 hago el intercambio.

Al final no regresamos nada porque hemos modificado al arreglo directamente así que el que invoca la función puede usar el arreglo ya ordenado.

Ordenamiento de burbuja en Java con Strings

Podemos usar el método compareTo en Java para saber si una cadena es mayor o menor que otra. En este caso el código es casi el mismo, solo comparamos de manera distinta y tenemos tipo de dato cadena.

Queda así:

private static void burbuja(String[] arreglo) {
    for (int x = 0; x < arreglo.length; x++) {
        // Aquí "y" se detiene antes de llegar
        // a length - 1 porque dentro del for, accedemos
        // al siguiente elemento con el índice actual + 1
        for (int y = 0; y < arreglo.length - 1; y++) {
            String elementoActual = arreglo[y],
                    elementoSiguiente = arreglo[y + 1];
            if (elementoActual.compareTo(elementoSiguiente) > 0) {
                // Intercambiar
                arreglo[y] = elementoSiguiente;
                arreglo[y + 1] = elementoActual;
            }
        }
    }
}

¿Ascendente o descendente?

Al aplicar el código que mencioné anteriormente obtenemos un arreglo ordenado de manera ascendente. Si quieres que sea de forma descendente simplemente invierte la comparación.

En el primer caso comparamos con elementoActual > elementoSiguiente, hay que cambiarlo a elementoActual < elementoSiguiente.

Cuando ordenamos arreglos de cadena lo mismo, solo cambiamos lo que regrese compareTo a un < 0 en lugar de un > 0.

Poniendo todo junto

Llegó el momento de probar el método de ordenamiento de burbuja en Java. Todo el código queda así:

import java.util.Arrays;
/*
 * Método de burbuja en Java para ordenar arreglos
 *
 * @author parzibyte
 * @see https://parzibyte.me/blog
 * */
public class MetodoBurbuja {
    public static void main(String[] args) {
        int numeros[] = {1, 9, 23, 4, 55, 100, 1, 1, 23};
        System.out.println("Antes del método de la burbuja: " + Arrays.toString(numeros));
        burbuja(numeros);
        System.out.println("Después del método de la burbuja: " + Arrays.toString(numeros));
        String[] nombres = {"Leon", "Chris", "Jill", "Wesker", "Ada"};
        System.out.println("Antes del método de la burbuja: " + Arrays.toString(nombres));
        burbuja(nombres);
        System.out.println("Después del método de la burbuja: " + Arrays.toString(nombres));
    }

    private static void burbuja(int[] arreglo) {
        for (int x = 0; x < arreglo.length; x++) {
            // Aquí "y" se detiene antes de llegar
            // a length - 1 porque dentro del for, accedemos
            // al siguiente elemento con el índice actual + 1
            for (int y = 0; y < arreglo.length - 1; y++) {
                int elementoActual = arreglo[y],
                        elementoSiguiente = arreglo[y + 1];
                if (elementoActual > elementoSiguiente) {
                    // Intercambiar
                    arreglo[y] = elementoSiguiente;
                    arreglo[y + 1] = elementoActual;
                }
            }
        }
    }

    private static void burbuja(String[] arreglo) {
        for (int x = 0; x < arreglo.length; x++) {
            // Aquí "y" se detiene antes de llegar
            // a length - 1 porque dentro del for, accedemos
            // al siguiente elemento con el índice actual + 1
            for (int y = 0; y < arreglo.length - 1; y++) {
                String elementoActual = arreglo[y],
                        elementoSiguiente = arreglo[y + 1];
                if (elementoActual.compareTo(elementoSiguiente) > 0) {
                    // Intercambiar
                    arreglo[y] = elementoSiguiente;
                    arreglo[y + 1] = elementoActual;
                }
            }
        }
    }
}

La ejecución del código es como se ve a continuación. Por cierto, como puedes notar, utilizo Arrays.toString para convertir el arreglo a cadena fácilmente; esto es con propósitos de imprimirlos sin tener que usar mucho código.

Te invito a aprender más sobre Java en mi blog.