Saltar al contenido principal
Interactive Algorithm Education

Visualize & Master Algorithms & Data Structures

Explore classic & modern sorting algorithms, efficient searching techniques, and interactive data structure visualizations — all with real-time step-by-step animation, comparisons, swaps, and Big-O metrics.

Sorting Visualizer

Bubble Sort

Speed 100ms
Size 20
Step Progress 0 / 0
Comparisons 0
Swaps / Shifts 0
Status Ready
Default
Comparing
Swapping
Pivot / Min
Sorted
⬡ Held key (ghost)
Step Explanation

Click 'Play' or 'Step Forward' to begin visualization.

Bubble Sort • Time: O(n²) • Space: O(1)
Pseudocode
        
History

Select an algorithm to see its history.

Ordenamiento Burbuja

Beginner (1/5) ~30 minutos Comparación de pares adyacentes Intercambio de vecinos desordenados Optimización basada en pasadas Salida anticipada adaptativa Prereqs: Arreglos, Bucles básicos
Quick Reference

Bubble Sort

Bubble Sort is a foundational comparison sort that repeatedly steps through an array, compares adjacent pairs, and swaps them if out of order. Larger values continuously bubble up to the end of the array.

Difficulty: Beginner (1/5) Stablesorting

Complexity

Best Time
O(n)
Average Time
O(n²)
Worst Time
O(n²)
Space
O(1)

When to Use

Best suited for small datasets, educational visual demonstrations, or arrays that are already known to be nearly sorted.

Pros

  • In-place algorithm requiring O(1) auxiliary space
  • Stable: preserves the relative order of duplicate elements
  • Adaptive: achieves O(n) best-case time when array is already sorted

Cons

  • Poor performance on large datasets (O(n²) comparisons and swaps)
  • High number of redundant data swap operations

History

Bubble Sort was first analyzed in the early 1950s. The term "bubble sort" was popularized by Kenneth E. Iverson in his 1962 book A Programming Language.

El Ordenamiento Burbuja recorre repetidamente un arreglo, intercambiando pares adyacentes desordenados hasta que todo está ordenado. Cada pasada “burbuja” el valor restante más grande hacia el final.

Piensa en una fila de asistentes a un concierto donde solo puedes intercambiar dos vecinos a la vez. Camina de izquierda a derecha, intercambiando cada par que esté desordenado. La persona más pesada burbujea hacia el final después de cada pasada — de ahí el nombre.

Cómo Funciona

  1. Comienza en el índice 0 y recorre hasta el final de la región no ordenada actual.
  2. Compara cada par de elementos adyacentes arr[j] y arr[j+1].
  3. Si arr[j] > arr[j+1], intercámbialos para que el valor mayor se desplace a la derecha.
  4. Después de una pasada completa, el valor más grande se ha asentado al final — marca esa posición como ordenada.
  5. Repite, reduciendo la región no ordenada en uno cada vez, hasta que una pasada complete con cero intercambios (el arreglo ya está ordenado).

Idea Clave

La salida anticipada es la idea clave. Si una pasada completa no realiza intercambios, cada par adyacente ya está en orden — el arreglo completo está ordenado. Esta adaptividad le da al Ordenamiento Burbuja su caso mejor O(n), una propiedad rara entre los ordenamientos ingenuos.

El trade-off: muchas más comparaciones de las necesarias en arreglos grandes y aleatorios. Es por eso que el Ordenamiento por Insercción lo supera en casi todos los escenarios prácticos.

Ejemplo Trabajado

Ordena [5, 3, 8, 1, 2] con Ordenamiento Burbuja:

Pasada 1 (compara/intercambia de izquierda a derecha):

  • 5 vs 3 → intercambiar → [3, 5, 8, 1, 2]
  • 5 vs 8 → mantener → [3, 5, 8, 1, 2]
  • 8 vs 1 → intercambiar → [3, 5, 1, 8, 2]
  • 8 vs 2 → intercambiar → [3, 5, 1, 2, 8] — 8 ya está en casa

Pasada 2 (ignora la última posición):

  • 3 vs 5 → mantener → [3, 5, 1, 2, 8]
  • 5 vs 1 → intercambiar → [3, 1, 5, 2, 8]
  • 5 vs 2 → intercambiar → [3, 1, 2, 5, 8] — 5 ya está en casa

Pasada 3:

  • 3 vs 1 → intercambiar → [1, 3, 2, 5, 8]
  • 3 vs 2 → intercambiar → [1, 2, 3, 5, 8] — 3 ya está en casa

Pasada 4:

  • 1 vs 2 → mantener → [1, 2, 3, 5, 8] — sin intercambios, salida anticipada

Resultado: [1, 2, 3, 5, 8]. Observa la animación arriba — cada pasada colorea el elemento recién asentado, y las comparaciones se detienen temprano porque la pasada 4 no realiza intercambios.

Casos Extremos y Trampas

  • Entrada ya ordenada — una pasada detecta cero intercambios y termina en O(n).
  • “Entrada ordenada inversa — el peor caso: cada pasada realiza el número máximo de intercambios, O(n²).”
  • “Duplicados — El Ordenamiento Burbuja es estable: los valores iguales nunca se cruzan, ya que solo intercambiamos en > estricto. Esto importa cuando se ordena por múltiples claves (ej., precio, luego nombre).”
  • Conjuntos de datos grandes — evita el Ordenamiento Burbuja para datos de producción. Degrada cuadráticamente y realiza muchas más comparaciones de las necesarias.

Comparación con Otros Ordenamientos

EscenarioOrdenamiento BurbujaOrdenamiento por InsercciónOrdenamiento por Selección
Entrada casi ordenadaO(n) con salida anticipadaO(n), menos comparacionesO(n²) siempre
Entrada aleatoriaO(n²), muchos intercambiosO(n²), menos intercambiosO(n²), menos intercambios
EstabilidadEstableEstableInestable
Mejor cuandoAprendizaje / entradas muy pequeñasDatos pequeños o casi ordenadosLos writes de memoria son costosos

El Ordenamiento por Insercción domina en la práctica: misma complejidad, menos comparaciones e intercambios, y mejor comportamiento de caché. El verdadero valor del Ordenamiento Burbuja hoy es pedagógico.

Aplicaciones

  • Enseñar la mecánica de ordenamiento por comparación y estabilidad
  • Detectar un arreglo casi ordenado baratamente (la pasada de salida anticipada)
  • Conjuntos de datos muy pequeños donde la simplicidad supera a la velocidad

Trayectoria de Práctica

  1. Traza a mano el Ordenamiento Burbuja en [4, 2, 7, 1, 3], escribiendo el arreglo después de cada intercambio.
  2. Agrega la optimización de bandera de intercambio y explica por qué convierte el mejor caso en O(n).
  3. Prueba que después de la pasada k, los k elementos más grandes están en sus posiciones finales.
  4. Traza una ejecución con duplicados ([3, 1, 3, 2]) y confirma que el orden relativo de los dos 3s se preserva.
  5. Implementa el Ordenamiento Burbuja iterativamente, luego explica por qué la versión ingenua siempre toma n-1 pasadas incluso cuando el arreglo ya está ordenado.