Ordenamiento de burbuja
Última actualización
El ordenamiento de burbuja recorre repetidamente la lista, compara cada par de elementos adyacentes y los intercambia si están en el orden incorrecto. Después de cada pasada completa, el valor más grande restante ha "burbujeado" hasta su posición correcta al final, por lo que cada pasada examina un elemento menos. Pulsa reproducir arriba para ver las comparaciones y los intercambios, o avanza por ellos de uno en uno.
Es uno de los algoritmos de ordenamiento más fáciles de entender, lo que lo convierte en un gran primer algoritmo, pero su tiempo de ejecución O(n²) lo hace poco práctico para entradas grandes.
Complejidad temporal y espacial
| Caso | Complejidad | Notas |
|---|---|---|
| Mejor caso | O(n) | Ya ordenado, con una comprobación de salida anticipada |
| Caso promedio | O(n²) | Orden aleatorio |
| Peor caso | O(n²) | Ordenado a la inversa |
| Espacio | O(1) | En el lugar, solo una variable temporal |
| Estable | Sí | Los elementos iguales conservan su orden relativo |
Paso a paso
| Paso | Qué ocurre |
|---|---|
| 1 | Empieza al inicio del arreglo. |
| 2 | Compara el elemento actual con el siguiente. |
| 3 | Si están desordenados, intercámbialos. |
| 4 | Avanza una posición a la derecha y repite hasta el final (una pasada). |
| 5 | Repite las pasadas; cada pasada fija un elemento más al final. |
| 6 | Detente cuando una pasada completa no haga intercambios. |
Ejemplo resuelto
Ordenando [5, 2, 4, 1]:
| Pasada | Arreglo | Acción |
|---|---|---|
| 1 | [2, 4, 1, 5] | Intercambia 5,2, luego 5,4, luego 5,1; el 5 burbujea hasta el final. |
| 2 | [2, 1, 4, 5] | 2,4 en orden; intercambia 4,1; 4,5 en orden; el 4 queda colocado. |
| 3 | [1, 2, 4, 5] | Intercambia 2,1; el resto ya está en orden; el 2 queda colocado. |
| 4 | [1, 2, 4, 5] | Una pasada completa no hace intercambios, así que el arreglo está ordenado y el algoritmo se detiene. |
Cuándo usar el ordenamiento de burbuja
| Úsalo cuando | Evítalo cuando |
|---|---|
| Enseñas o aprendes cómo funcionan los ordenamientos por comparación | Ordenas entradas grandes, donde O(n²) es demasiado lento |
La entrada es diminuta o casi ordenada (con salida anticipada se acerca a O(n)) | Necesitas el ordenamiento de propósito general más rápido: usa quicksort o merge sort |
| Necesitas un ordenamiento estable, en el lugar y con casi nada de código | Los datos están en orden aleatorio y el rendimiento importa |
| Detectas si una lista corta ya está ordenada en una sola pasada | Muchas escrituras son costosas (p. ej. memoria flash); el ordenamiento por selección hace menos intercambios |
Código de Bubble Sort
Una implementación limpia y ejecutable de Bubble Sort en Python, JavaScript, Java, C++, C. Elige un lenguaje, copia el código o ábrelo ya cargado en el Playground de Coddy.
Código de Bubble Sort en Python
Python
1def bubble_sort(a):2 n = len(a)3 for i in range(n - 1):4 swapped = False5 for j in range(n - 1 - i):6 if a[j] > a[j + 1]:7 a[j], a[j + 1] = a[j + 1], a[j]8 swapped = True9 if not swapped:10 break # no swaps means the list is already sorted11 return a12
13
14nums = [5, 1, 4, 2, 8]15print("Before:", nums)16bubble_sort(nums)17print("After: ", nums)Código de Bubble Sort en JavaScript
JavaScript
1function bubbleSort(a) {2 for (let end = a.length - 1; end > 0; end--) {3 let swapped = false;4 for (let j = 0; j < end; j++) {5 if (a[j] > a[j + 1]) {6 [a[j], a[j + 1]] = [a[j + 1], a[j]];7 swapped = true;8 }9 }10 if (!swapped) break; // Already sorted: stop early11 }12 return a;13}14
15const data = [5, 2, 9, 1, 7, 3];16console.log("Before:", data);17console.log("Sorted:", bubbleSort([...data]));Código de Bubble Sort en Java
Java
1import java.util.Arrays;2
3public class Main {4 static void bubbleSort(int[] arr) {5 for (int i = arr.length - 1; i > 0; i--) {6 boolean swapped = false;7 for (int j = 0; j < i; j++) {8 if (arr[j] > arr[j + 1]) {9 int tmp = arr[j];10 arr[j] = arr[j + 1];11 arr[j + 1] = tmp;12 swapped = true;13 }14 }15 if (!swapped) break; // already sorted16 }17 }18
19 public static void main(String[] args) {20 int[] arr = {5, 1, 4, 2, 8, 3};21 System.out.println("Before: " + Arrays.toString(arr));22 bubbleSort(arr);23 System.out.println("After: " + Arrays.toString(arr));24 }25}Código de Bubble Sort en C++
C++
1#include <iostream>2#include <utility>3#include <vector>4
5void printVec(const std::vector<int>& a) {6 for (int x : a) std::cout << x << " ";7 std::cout << "\n";8}9
10void bubbleSort(std::vector<int>& a) {11 for (size_t pass = 0; pass + 1 < a.size(); ++pass) {12 bool swapped = false;13 // Each pass bubbles the largest remaining value to the end14 for (size_t j = 0; j + 1 < a.size() - pass; ++j) {15 if (a[j] > a[j + 1]) {16 std::swap(a[j], a[j + 1]);17 swapped = true;18 }19 }20 if (!swapped) break; // already sorted21 }22}23
24int main() {25 std::vector<int> data = {5, 1, 4, 2, 8, 3};26 std::cout << "Before: ";27 printVec(data);28 bubbleSort(data);29 std::cout << "After: ";30 printVec(data);31 return 0;32}Código de Bubble Sort en C
C
1#include <stdbool.h>2#include <stdio.h>3
4void printArr(const int a[], int n) {5 for (int i = 0; i < n; i++) printf("%d ", a[i]);6 printf("\n");7}8
9void bubbleSort(int a[], int n) {10 for (int pass = 0; pass < n - 1; pass++) {11 bool swapped = false;12 // Each pass bubbles the largest remaining value to the end13 for (int j = 0; j < n - 1 - pass; j++) {14 if (a[j] > a[j + 1]) {15 int tmp = a[j];16 a[j] = a[j + 1];17 a[j + 1] = tmp;18 swapped = true;19 }20 }21 if (!swapped) break; // already sorted22 }23}24
25int main(void) {26 int data[] = {5, 1, 4, 2, 8, 3};27 int n = sizeof(data) / sizeof(data[0]);28 printf("Before: ");29 printArr(data, n);30 bubbleSort(data, n);31 printf("After: ");32 printArr(data, n);33 return 0;34}Preguntas frecuentes sobre el ordenamiento de burbuja
¿Cuál es la complejidad temporal del ordenamiento de burbuja?
El ordenamiento de burbuja se ejecuta en tiempo
O(n²) en los casos promedio y peor debido a los bucles anidados. Con una optimización de salida anticipada puede alcanzar O(n) en un arreglo ya ordenado. Usa O(1) de espacio adicional.¿Es estable el ordenamiento de burbuja?
Sí. El ordenamiento de burbuja solo intercambia elementos adyacentes cuando están estrictamente desordenados, por lo que los elementos iguales nunca se cruzan y conservan su orden relativo original.
¿Por qué se llama ordenamiento de burbuja?
En cada pasada el valor más grande sin ordenar se mueve paso a paso hacia el final del arreglo, como una burbuja que sube a la superficie, de ahí el nombre "burbuja".
¿Cuál es la diferencia entre el ordenamiento de burbuja y el ordenamiento por inserción?
Ambos se ejecutan en
O(n²) y son estables y en el lugar, pero mueven los datos de forma distinta: el ordenamiento de burbuja intercambia repetidamente pares adyacentes desordenados, mientras que el de inserción toma cada elemento y lo desliza hasta su lugar correcto dentro del prefijo ordenado. El ordenamiento por inserción suele hacer menos escrituras y ser más rápido en la práctica, sobre todo con datos casi ordenados.¿Cuándo debería usar el ordenamiento de burbuja en lugar de quicksort?
Casi nunca para cargas de trabajo reales: el tiempo promedio
O(n log n) de quicksort aplasta al O(n²) del ordenamiento de burbuja en todo salvo entradas diminutas. El ordenamiento de burbuja solo merece la pena cuando la lista es muy pequeña o casi ordenada, o cuando quieres el ordenamiento estable más simple posible para enseñar.¿La optimización de salida anticipada cambia el peor caso del ordenamiento de burbuja?
No. Registrar si una pasada hizo algún intercambio permite al ordenamiento de burbuja detenerse antes y alcanzar
O(n) en entradas ya ordenadas, pero un arreglo ordenado a la inversa aún necesita todas las comparaciones, así que el peor caso sigue siendo O(n²). La optimización solo ayuda en el mejor caso y en los casi ordenados.Recursos relacionados
Más visualizaciones
