Introducción

El ordenamiento de burbuja (bubble sort) es uno de los algoritmos de clasificación más sencillos y didácticos. A pesar de su bajo rendimiento en grandes volúmenes de datos (O(n²)), sigue siendo útil para enseñar conceptos básicos de algoritmos, detección de orden y optimizaciones simples.

¿Cómo funciona?

El algoritmo recorre la lista repetidamente, comparando pares adyacentes y intercambiándolos si están en el orden incorrecto. Cada pasada "burbujea" el elemento más grande (o más pequeño, según el criterio) al final de la porción no ordenada.

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

El bucle externo controla cuántas pasadas se realizan; el interno compara y ordena los pares.

Complejidad Temporal y Espacial

• Mejor caso (lista ya ordenada con optimización de salida temprana): O(n)
• Caso promedio y peor caso: O(n²)
• Espacio adicional: O(1) (ordenamiento in‑place)

Optimización: Detección de Ordenación Temprana

Si en una pasada no se realizan intercambios, la lista ya está ordenada y podemos detener el algoritmo.

def bubble_sort_optimized(arr):
    n = len(arr)
    for i in range(n):
        swapped = False
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break
    return arr

Ejemplo paso a paso

Ordenemos [5, 1, 4, 2, 8]:

1. Primera pasada: 5↔1 → [1,5,4,2,8]; 5↔4 → [1,4,5,2,8]; 5↔2 → [1,4,2,5,8]. El 8 ya está en su posición final.
2. Segunda pasada: 1↔4 (no cambia); 4↔2 → [1,2,4,5,8]. El 5 está en su sitio.
3. Tercera pasada: no se realizan intercambios → algoritmo termina (optimizado).

Resultado final: [1,2,4,5,8].

Comparativa con Otros Algoritmos de Ordenación

Casos de Uso Reales

• Ordenamiento de listas de configuración muy pequeñas en scripts de automatización.
• Educación: demostraciones visuales de algoritmos en aulas de programación.
• Entornos embebidos con recursos extremadamente limitados donde la sobrecarga de algoritmos más complejos no justifica.

Buenas Prácticas y Tips de Optimización

• Usa la versión bubble_sort_optimized siempre que sea posible.
• Si la lista supera los 10 000 elementos, considera cambiar a sorted() de Python (TimSort).
• Para datos casi ordenados, combina bubble sort con insertion sort para reducir la constante.
• Evita mutar listas globales; devuelve una nueva lista o trabaja con copias.

Depuración y Troubleshooting

Si el algoritmo parece no terminar:

• Verifica que el bucle interno use n - i - 1 como límite; de lo contrario podrías entrar en un bucle infinito.
• Comprueba que la condición de intercambio sea correcta (arr[j] > arr[j+1] para orden ascendente).
• Utiliza print o un debugger para observar el estado de la lista después de cada pasada.

Rendimiento: Benchmark rápido

import random, timeit
def benchmark(size=1000):
    data = random.sample(range(size*10), size)
    t1 = timeit.timeit(lambda: bubble_sort_optimized(data.copy()), number=5)
    t2 = timeit.timeit(lambda: sorted(data), number=5)  # TimSort de Python
    print(f"Bubble Sort (opt): {t1:.4f}s vs built‑in sorted: {t2:.4f}s")
benchmark(500)  # Prueba con 500 elementos

En la mayoría de los equipos modernos, sorted() será varias veces más rápido que bubble sort incluso con la optimización.

Conclusión

El algoritmo de ordenamiento de burbuja es una herramienta pedagógica fundamental y, con la optimización de salida temprana, puede ser práctico para listas diminutas o casi ordenadas. Sin embargo, para aplicaciones de producción con volúmenes de datos significativos, siempre es preferible usar algoritmos más eficientes como TimSort (función sorted() de Python) o Quicksort.