El algoritmo de ordenación por burbuja es uno de los métodos más sencillos para ordenar vectores o arrays, aunque también es uno de los menos eficientes. Su funcionamiento básico consiste en recorrer el array comparando elementos adyacentes y, cuando detectamos que un elemento es mayor que el siguiente, los intercambiamos para ir empujando los valores más grandes hacia el final del array.
Para entenderlo mejor, imaginemos un array con seis elementos. En la primera pasada, comparamos el primer elemento con el segundo; si el primero es mayor, los intercambiamos. Luego comparamos el segundo con el tercero, y así sucesivamente hasta llegar al final del array. En este proceso, el elemento más grande se mueve rápidamente hacia la última posición. Por ejemplo, si el número 6 está al principio, tras una pasada completa habrá llegado al final.
Este proceso se repite n-1 veces, siendo n el tamaño del array. La razón es que un elemento muy desordenado, como el menor que está al final, necesita tantas pasadas para llegar a la primera posición, moviéndose un paso a la vez. Sin embargo, esta repetición fija es una de las causas principales de la ineficiencia del algoritmo, ya que muchas veces se realizan pasadas completas incluso cuando el array ya está ordenado.
Durante cada pasada, se hacen comparaciones entre pares de elementos adyacentes. Si están en el orden correcto (el primero menor o igual que el segundo), no se hace nada. Pero si están desordenados, se intercambian. Por ejemplo, si comparamos 4 y 2, como 4 es mayor, los intercambiamos. Si luego comparamos 4 y 5, no hacemos nada porque ya están en orden.
Una desventaja importante es que el algoritmo no recuerda si en una pasada anterior ya no hubo intercambios, por lo que sigue haciendo comparaciones innecesarias. Esto significa que incluso cuando el array está ordenado, el algoritmo sigue recorriéndolo varias veces, perdiendo eficiencia.
El código que implementa este algoritmo suele tener dos bucles anidados. El externo se repite n-1 veces, y el interno recorre el array desde el primer elemento hasta el penúltimo, comparando cada elemento con el siguiente y realizando intercambios cuando es necesario. Es importante que el bucle interno no llegue hasta el último elemento para evitar acceder a una posición fuera del array.
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
Aunque este código funciona, podemos optimizarlo para evitar pasos innecesarios. Una forma sencilla es introducir una variable que detecte si en una pasada se ha realizado algún intercambio. Si en una pasada completa no se produce ningún intercambio, significa que el array ya está ordenado y podemos detener el algoritmo antes de completar todas las pasadas.
Para ello, usamos una variable booleana, por ejemplo desorden, que se pone a true cuando se realiza un intercambio. Al inicio de cada pasada, la inicializamos a false. Si al final de la pasada sigue siendo false, salimos del bucle porque no hay más desorden.
Este enfoque mejora la eficiencia especialmente cuando el array está parcialmente ordenado, ya que evita comparaciones y pasadas innecesarias.
boolean desorden;
do {
desorden = false;
for (int j = 0; j < n - 1; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
desorden = true;
}
}
} while (desorden);
Aunque existen algoritmos más eficientes como la ordenación por inserción o selección, y variantes mejoradas del algoritmo de burbuja como el algoritmo del peine, esta optimización básica puede hacer que el algoritmo de burbuja sea un poco menos ineficiente en casos donde el array no está completamente desordenado. Sin embargo, para usos reales, es recomendable optar por métodos más avanzados y eficientes.