Ordenamiento de burbuja

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo uno de los más sencillos de implementar.

Representación animada de ordenación de un conjunto de números mediante el algoritmo burbuja. Comenzando desde el inicio del arreglo, se compara cada par de elementos adyacentes. Si ambos no están ordenados (el segundo es menor que el primero), se intercambian sus posiciones. En cada iteración, un elemento menos necesita ser evaluados (el último), ya que no hay más elementos a su derecha que necesiten ser comparados, puesto que ya están ordenados.

Descripción

Una manera simple de expresar el ordenamiento de burbuja en pseudocódigo es la siguiente:

${\displaystyle {\color {Sepia}{\mathit {procedimiento}}}\;{\color {red}{\mathit {DeLaBurbuja}}}\;({\color {Black}{\mathit {a}}}{\color {Plum}{\mathit {{}_{0}}}},{\color {Black}{\mathit {a}}}{\color {Plum}{\mathit {{}_{1}}}},{\color {Black}{\mathit {a}}}{\color {Plum}{\mathit {{}_{2}}}},\ldots ,{\color {Black}{\mathit {a}}}{}_{(}{\color {black}{\mathit {{}_{n}}}}{\color {Blue}{\mathit {{}_{-}}}}{\color {Plum}{\mathit {{}_{1}}}}{}_{)})}$  ${\displaystyle {\color {Sepia}{\mathit {para}}}\;{\color {Black}{\mathit {i}}}\;{\color {Blue}{\mathit {\gets }}}\;{\color {Plum}{\mathit {1}}}\;{\color {Sepia}{\mathit {hasta}}}\;{\color {Black}{\mathit {n}}}\;{\color {Blue}{\mathit {-}}}\;{\color {Plum}{\mathit {1}}}\;{\color {Sepia}{\mathit {hacer}}}}$  ${\displaystyle {\color {Sepia}{\mathit {para}}}\;{\color {Black}{\mathit {j}}}\;{\color {Blue}{\mathit {\gets }}}\;{\color {Plum}{\mathit {0}}}\;{\color {Sepia}{\mathit {hasta}}}\;{\color {Black}{\mathit {n}}}\;{\color {Blue}{\mathit {-}}}\;{\color {Black}{\mathit {i}}}\;{\color {Blue}{\mathit {-}}}\;{\color {Plum}{\mathit {1}}}\;{\color {Sepia}{\mathit {hacer}}}}$  ${\displaystyle {\color {Sepia}{\mathit {si}}}\;{\color {Black}{\mathit {a}}}{}_{(}{\color {Black}{\mathit {{}_{j}}}}{}_{)}\;{\color {Blue}{\mathit {>}}}\;{\color {Black}{\mathit {a}}}{}_{(}{\color {Black}{\mathit {{}_{j}}}}{\color {Blue}{\mathit {{}_{+}}}}{\color {Plum}{\mathit {{}_{1}}}}{}_{)}\;{\color {Sepia}{\mathit {entonces}}}}$  ${\displaystyle {\color {Black}{\mathit {aux}}}\;{\color {Blue}{\mathit {\gets }}}\;{\color {Black}{\mathit {a}}}{}_{(}{\color {Black}{\mathit {{}_{j}}}}{}_{)}\;}$  ${\displaystyle {\color {Black}{\mathit {a}}}{}_{(}{\color {Black}{\mathit {{}_{j}}}}{}_{)}\;{\color {Blue}{\mathit {\gets }}}\;{\color {Black}{\mathit {a}}}{}_{(}{\color {Black}{\mathit {{}_{j}}}}{\color {Blue}{\mathit {{}_{+}}}}{\color {Plum}{\mathit {{}_{1}}}}{}_{)}}$  ${\displaystyle {\color {Black}{\mathit {a}}}{}_{(}{\color {Black}{\mathit {{}_{j}}}}{\color {Blue}{\mathit {{}_{+}}}}{\color {Plum}{\mathit {{}_{1}}}}{}_{)}\;{\color {Blue}{\mathit {\gets }}}\;{\color {Black}{\mathit {aux}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;si}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;para}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;para}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;procedimiento}}}}$

Este algoritmo realiza el ordenamiento o reordenamiento de una lista a de n valores, en este caso de n términos numerados del 0 al n-1; consta de dos bucles anidados, uno con el índice i, que da un tamaño menor al recorrido de la burbuja en sentido inverso de 2 a n, y un segundo bucle con el índice j, con un recorrido desde 0 hasta n-i, para cada iteración del primer bucle, que indica el lugar de la burbuja.

La burbuja son dos términos de la lista seguidos, j y j+1, que se comparan: si el primero es mayor que el segundo sus valores se intercambian.

Esta comparación se repite en el centro de los dos bucles, dando lugar a una lista ordenada. Puede verse que el número de repeticiones solo depende de n y no del orden de los términos, esto es, si pasamos al algoritmo una lista ya ordenada, realizará todas las comparaciones exactamente igual que para una lista no ordenada. Esta es una característica de este algoritmo. Luego veremos una variante que evita este inconveniente.

Para comprender el funcionamiento, veamos un ejemplo sencillo:

Tenemos una lista de números que hay que ordenar:

${\displaystyle a=\{55,86,48,16,82\}\,}$ 

${\displaystyle {\begin{array}{r}a_{4}=82\\a_{3}=16\\a_{2}=48\\a_{1}=86\\a_{0}=55\end{array}}}$

Podemos ver que la lista que tiene cinco términos, luego:

${\displaystyle n=5\,}$ 

El índice i hará un recorrido de 2 hasta n:

${\displaystyle {\color {Sepia}{\mathit {para}}}\;{\color {Black}{\mathit {i}}}\;{\color {BlueViolet}{\mathit {\gets }}}\;{\color {Black}{\mathit {2}}}\;{\color {Sepia}{\mathit {hasta}}}\;{\color {Black}{\mathit {n}}}\;{\color {Sepia}{\mathit {hacer}}}}$ 

que en este caso será de 2 a 5. Para cada uno de los valores de i, j tomará sucesivamente los valores de 0 hasta n-i:

${\displaystyle {\color {Sepia}{\mathit {para}}}\;{\color {Black}{\mathit {j}}}\;{\color {BlueViolet}{\mathit {\gets }}}\;{\color {Black}{\mathit {0}}}\;{\color {Sepia}{\mathit {hasta}}}\;{\color {Black}{\mathit {n-i}}}\;{\color {Sepia}{\mathit {hacer}}}}$ 

Para cada valor de j, obtenido en ese orden, se compara el valor del índice j con el siguiente:

${\displaystyle {\color {Sepia}{\mathit {si}}}\;{\color {Black}a_{(j)}}\;{\color {BlueViolet}>}\;{\color {Black}a_{(j+1)}}\;{\color {Sepia}{\mathit {entonces}}}}$ 

Si el término j es mayor que el término j+1, los valores se permutan, en caso contrario se continúa con la iteración.

${\displaystyle {\begin{array}{r||r|r|r|r|r}&j=0&j=1&j=2&j=3&\\\hline a_{4}&82&82&82&\to 82&86\\a_{3}&16&16&\to 16&\to 86&82\\a_{2}&48&\to 48&\to 86&16&16\\a_{1}&\to 86&\to 86&48&48&48\\a_{0}&\to 55&55&55&55&55\end{array}}}$

Para el caso del ejemplo, tenemos que:

${\displaystyle n=5\,}$ 

Para la primera iteración del primer bucle:

${\displaystyle i=2\,}$ 

y j tomará los valores de 0 hasta 3:

${\displaystyle {\color {Sepia}{\mathit {para}}}\;{\color {Black}{\mathit {j}}}\;{\color {BlueViolet}{\mathit {\gets }}}\;{\color {Black}{\mathit {0}}}\;{\color {Sepia}{\mathit {hasta}}}\;{\color {Black}{\mathit {3}}}\;{\color {Sepia}{\mathit {hacer}}}}$ 

Cuando j vale 0, se comparan ${\displaystyle a_{0}\;a_{1}}$ , el 55 y el 86, dado que 55 < 86, no se permuta el orden.

Ahora j vale 1 y se comparan ${\displaystyle a_{1}\;a_{2}}$  el 86 y el 48. Como 86 > 48, se permutan, dando lugar a una nueva lista.

Se repite el proceso hasta que j valga 3, dando lugar a una lista parcialmente ordenada. Podemos ver que el término de mayor valor está en el lugar más alto.

${\displaystyle {\begin{array}{r||r|r|r|r}&j=0&j=1&j=2&\\\hline a_{4}&86&86&86&86\\a_{3}&82&82&\to 82&82\\a_{2}&16&\to 16&\to 55&55\\a_{1}&\to 48&\to 55&16&16\\a_{0}&\to 55&48&48&48\end{array}}}$

Ahora i vale 3, y j hará un recorrido de 0 a 2.

Primero j vale 0, se comparan ${\displaystyle a_{0}\;a_{1}}$ , el 55 y el 48. Como 55 > 48 se permutan dando lugar a la nueva lista.

Para j = 1 se compara el 55 con el 16 y se cambian de orden.

Para j = 2 se compara el 55 y el 82 y se dejan como están, finalizando el bucle con una lista mejor ordenada. Puede verse que los dos valores más altos ya ocupan su lugar. No se ha realizado ninguna comparación con el término cuarto, dado que ya se sabe que después del primer ciclo es el mayor de la lista.

El algoritmo consiste en comparaciones sucesivas de dos términos consecutivos ascendiendo de abajo arriba en cada iteración, como la ascensión de las burbujas de aire en el agua, de ahí el nombre del procedimiento. En la primera iteración el recorrido ha sido completo, en el segundo se ha dejado él último término, al tener ya el mayor de los valores, en los sucesivos sé ira dejando de realizar las últimas comparaciones, como se puede ver.

${\displaystyle {\begin{array}{r||r|r|r}&j=0&j=1&\\\hline a_{4}&86&86&86\\a_{3}&82&82&82\\a_{2}&55&\to 55&55\\a_{1}&\to 16&\to 48&48\\a_{0}&\to 48&16&16\end{array}}}$

Ahora ya i vale 4 y j recorrerá los valores de 0 a 1.

Cuando j vale 0, se comparan ${\displaystyle a_{0}\;a_{1}}$ , esto es, el 48 y el 16. Dado que 48 es mayor que 16 se permutan los valores, dando lugar a una lista algo más ordenada que la anterior. Desde esta nueva ordenación, j pasa a valer 1, con lo que se comparan los términos ${\displaystyle a_{1}\;a_{2}}$  el 48 y el 55 que quedan en el mismo orden.

En este caso la burbuja ha ascendido menos que en los casos anteriores, y la lista está ya ordenada, pero el algoritmo tendrá que completarse, realizando una última iteración.

Hay que tener en cuenta que el bucle realiza un número fijo de repeticiones y para finalizar tendrán que completarse, aun en el caso extremo, de que la lista estuviera previamente ordenada.

Por último i vale 5 y j solo puede vale 0, con lo que sólo se realizará una comparación de ${\displaystyle a_{0}\;a_{1}}$  el 16 y el 48, que ya están ordenados y se dejan igual.

${\displaystyle {\begin{array}{r||r|r}&j=0&\\\hline a_{4}&86&86\\a_{3}&82&82\\a_{2}&55&55\\a_{1}&\to 48&48\\a_{0}&\to 16&16\end{array}}}$

Los bucles finalizan y también el procedimiento, dejando la lista ordenada.

Una variante que finaliza en caso de que la lista esté ordenada, puede ser la siguiente: como en el ejemplo anterior, empleando un centinela ordenado, que detecta que no se ha modificado la lista en un recorrido de la burbuja, y que por tanto la lista ya está ordenada, finalizando inmediatamente.

${\displaystyle {\color {Sepia}procedimiento}\;{\color {BlueViolet}DeLaBurbuja2}\;({\color {Black}a_{(0)},a_{(1)},a_{(2)},\ldots ,a_{(n-1)}})}$  ${\displaystyle {\color {Black}i}\;{\color {BlueViolet}\gets }\;{\color {Black}1}\;}$  ${\displaystyle {\color {Black}ordenado}\;{\color {BlueViolet}\gets }\;{\color {Black}no}\;}$  ${\displaystyle {\color {Sepia}{\mathit {mientras}}}\;{\color {Black}{\mathit {(i<n)\;\land \;(ordenado=no)}}}\;{\color {Sepia}{\mathit {hacer}}}}$  ${\displaystyle {\color {Black}i}\;{\color {BlueViolet}\gets }\;{\color {Black}i+1}\;}$  ${\displaystyle {\color {Black}ordenado}\;{\color {BlueViolet}\gets }\;{\color {Black}si}\;}$  ${\displaystyle {\color {Sepia}{\mathit {para}}}\;{\color {Black}{\mathit {j}}}\;{\color {BlueViolet}{\mathit {\gets }}}\;{\color {Black}{\mathit {0}}}\;{\color {Sepia}{\mathit {hasta}}}\;{\color {Black}{\mathit {n-i}}}\;{\color {Sepia}{\mathit {hacer}}}}$  ${\displaystyle {\color {Sepia}{\mathit {si}}}\;{\color {Black}a_{(j)}}\;{\color {BlueViolet}>}\;{\color {Black}a_{(j+1)}}\;{\color {Sepia}{\mathit {entonces}}}}$  ${\displaystyle {\color {Black}ordenado}\;{\color {BlueViolet}\gets }\;{\color {Black}no}\;}$  ${\displaystyle {\color {Black}aux}\;{\color {BlueViolet}\gets }\;{\color {Black}a_{(j)}}\;}$  ${\displaystyle {\color {Black}a_{(j)}}\;{\color {BlueViolet}\gets }\;{\color {Black}a_{(j+1)}}\;}$  ${\displaystyle {\color {Black}a_{(j+1)}}\;{\color {BlueViolet}\gets }\;{\color {Black}aux}\;}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;si}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;para}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;mientras}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;procedimiento}}}}$

${\displaystyle {\color {Sepia}procedimiento}\;{\color {BlueViolet}DeLaBurbuja3}\;({\color {Black}a_{(0)},a_{(1)},a_{(2)},\ldots ,a_{(n-1)}})}$  ${\displaystyle {\color {Black}i}\;{\color {BlueViolet}\gets }\;{\color {Black}1}\;}$  ${\displaystyle {\color {Sepia}{\mathit {repetir}}}}$  ${\displaystyle {\color {Black}i}\;{\color {BlueViolet}\gets }\;{\color {Black}i+1}\;}$  ${\displaystyle {\color {Black}ordenado}\;{\color {BlueViolet}\gets }\;{\color {Black}si}\;}$  ${\displaystyle {\color {Sepia}{\mathit {para}}}\;{\color {Black}{\mathit {j}}}\;{\color {BlueViolet}{\mathit {\gets }}}\;{\color {Black}{\mathit {0}}}\;{\color {Sepia}{\mathit {hasta}}}\;{\color {Black}{\mathit {n-i}}}\;{\color {Sepia}{\mathit {hacer}}}}$  ${\displaystyle {\color {Sepia}{\mathit {si}}}\;{\color {Black}a_{(j)}}\;{\color {BlueViolet}>}\;{\color {Black}a_{(j+1)}}\;{\color {Sepia}{\mathit {entonces}}}}$  ${\displaystyle {\color {Black}ordenado}\;{\color {BlueViolet}\gets }\;{\color {Black}no}\;}$  ${\displaystyle {\color {Black}aux}\;{\color {BlueViolet}\gets }\;{\color {Black}a_{(j)}}\;}$  ${\displaystyle {\color {Black}a_{(j)}}\;{\color {BlueViolet}\gets }\;{\color {Black}a_{(j+1)}}\;}$  ${\displaystyle {\color {Black}a_{(j+1)}}\;{\color {BlueViolet}\gets }\;{\color {Black}aux}\;}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;si}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;para}}}}$  ${\displaystyle {\color {Sepia}{\mathit {hasta\;que}}}\;{\color {Black}{\mathit {\neg (i<n)\;\lor \;(ordenado=si)}}}}$  ${\displaystyle {\color {Sepia}{\mathit {fin\;procedimiento}}}}$

Análisis

 

Rendimiento del algoritmo

Artículo principal: Cota ajustada asintótica

Al algoritmo de la burbuja, para ordenar un arreglo de n términos, tiene que realizar siempre el mismo número de comparaciones:

${\displaystyle c(n)={\cfrac {n^{2}-n}{2}}}$ 

Esto es, el número de comparaciones c(n) no depende del orden de los términos, si no del número de términos:

${\displaystyle \Theta (c(n))=n^{2}\;}$ 

Por lo tanto la cota ajustada asintótica del número de comparaciones pertenece al orden de n cuadrado.

El número de intercambios i(n), que hay que realizar depende del orden de los términos y podemos diferenciar, el caso mejor, si el arreglo está previamente ordenado, y el caso peor, si el arreglo está ordenado en orden inverso:

${\displaystyle \Theta (i(n))=?\;}$ 

Por lo que no se puede determinar una cota ajustada asintótica del número de intercambios, dado que éste dependerá del orden del arreglo en cuestión.

Rendimiento en el caso desfavorable

Artículo principal: Cota superior asintótica

Si pasamos al algoritmo un arreglo ordenado en orden inverso realizará un número de comparaciones:

${\displaystyle c(n)={\cfrac {n^{2}-n}{2}}}$ 

Como ya hemos dicho anteriormente, y tendrá que realizar un número igual de intercambios entre los términos del arreglo, dado que en cada comparación los términos estarán desordenados, y se realizará el intercambio.

${\displaystyle i(n)={\cfrac {n^{2}-n}{2}}}$ 

Por lo tanto en el caso más desfavorable tanto el número de comparaciones como el de intercambios coinciden:

${\displaystyle O(c(n))=O(i(n))=n^{2}\;}$ 

El número de comparaciones o de intercambios en el caso más desfavorable pertenece al orden de n cuadrado.

Rendimiento en casos óptimos

Artículo principal: Cota inferior asintótica

En el caso óptimo, el más favorable, es la ordenación de un arreglo ya ordenado. En este caso el número de comparaciones será el mismo que en cualquier otro caso:

${\displaystyle \Omega (c(n))=n^{2}\;}$ 

La cota inferior asintótica del número de comparaciones pertenece al orden de n cuadrado, como en los demás casos, pero en todas las comparaciones el orden es el correcto y por tanto no se realiza ningún intercambio:

${\displaystyle i(n)=0\;}$ 

Por lo tanto el coste de intercambios no depende de n, y es constante:

${\displaystyle \Omega (i(n))=1\;}$ 

El ordenamiento de burbuja tiene una complejidad Ω(n²) igual que ordenamiento por selección. Cuando una lista ya está ordenada, a diferencia del ordenamiento por inserción que pasará por la lista una vez y encontrará que no hay necesidad de intercambiar las posiciones de los elementos, el método de ordenación por burbuja está forzado a pasar por dichas comparaciones, lo que hace que su complejidad sea cuadrática en el mejor de los casos. Esto lo cataloga como uno de los algoritmos de ordenación más ineficientes que existen, aunque para muchos programadores sea el más sencillo de implementar.

Conejos y Tortugas

La posición de los elementos en el ordenamiento de burbuja juegan un papel muy importante en la determinación del rendimiento. Los elementos mayores al principio de la lista son rápidamente movidos hacia abajo, mientras los elementos menores en el fondo de la lista se mueven a la parte superior muy lentamente. Esto llevó a nombrar estos elementos conejos y tortugas, respectivamente.

Se han realizado varios esfuerzos para eliminar las tortugas (véase Exterminación) y mejorar la velocidad del ordenamiento de burbuja, la cual será más redonda que nunca. El Ordenamiento por sacudida es un buen ejemplo, aunque aún mantiene, en el peor de los casos, una complejidad O (n²). El ordenamiento por combinación compara los elementos primero en pedazos grandes de la lista, moviendo tortugas extremadamente rápido, antes de proceder a pedazos cada vez más pequeños para alisar la lista. Su velocidad promedio es comparable a algoritmos rápidos (y complejos) como el ordenamiento rápido.

En la práctica

A pesar de que el ordenamiento de burbuja es uno de los algoritmos más sencillos de implementar, su orden O (n²) lo hace muy ineficiente para usar en listas que tengan más que un número reducido de elementos. Incluso entre los algoritmos de ordenamiento de orden O (n²), otros procedimientos como el ordenamiento por inserción son considerados más eficientes.

Dada su simplicidad, el ordenamiento de burbuja es utilizado para introducir el concepto de algoritmo de ordenamiento para estudiantes de ciencias de la computación. A pesar de esto, algunos investigadores como Owen Astrachan han criticado su popularidad en la enseñanza de ciencias de la computación, llegando a recomendar su eliminación de los planes de estudio.^[1]​

Sumado a esto, Jargon File, un libro ampliamente citado en la cultura hacker, lo denomina "el mal algoritmo genérico", y Donald Knuth, uno de los mayores expertos en ciencias de la computación, afirma que el ordenamiento de burbuja "no parece tener nada para recomendar su uso, a excepción de un nombre pegadizo y el hecho de que conlleva a problemas teóricos interesantes".^[2]​

El ordenamiento de burbuja es asintóticamente equivalente en tiempos de ejecución con el ordenamiento por inserción en el peor de los casos, pero ambos algoritmos difieren principalmente en la cantidad de intercambios que son necesarios. Resultados experimentales como los descubiertos por Astrachan han demostrado que el ordenamiento por inserción funciona considerablemente mejor incluso con listas aleatorias. Por esta razón, muchos libros de algoritmos modernos evitan usar el ordenamiento de burbuja, reemplazándolo por el ordenamiento por inserción.

El ordenamiento de burbuja interactúa vagamente con el hardware de las CPU modernas. Requiere al menos el doble de escrituras que el ordenamiento por inserción, el doble de pérdidas de caché, y asintóticamente más predicción de saltos. Varios experimentos de ordenamiento de cadenas en Java hechos por Astrachan muestran que el ordenamiento de burbuja es 5 veces más lento que el ordenamiento por inserción, y 40% más lento que el ordenamiento por selección.^[1]​

Ejemplo paso a paso

Tomemos como ejemplo los números: "9 6 5 8 2 1", que serán ordenados de menor a mayor valor usando el método burbuja. Los elementos siguientes resaltados están siendo comparados.

Primera vuelta: ( 9 6 5 8 2 1 ) ${\displaystyle \to }$  ( 6 9 5 8 2 1 ), el algoritmo compara los primeros dos elementos y los cambia porque 9 > 6 ( 6 9 5 8 2 1 ) ${\displaystyle \to }$  ( 6 5 9 8 2 1 ) ( 6 5 9 8 2 1 ) ${\displaystyle \to }$  ( 6 5 8 9 2 1 ) ( 6 5 8 9 2 1 ) ${\displaystyle \to }$  ( 6 5 8 2 9 1 ) ( 6 5 8 2 9 1 ) ${\displaystyle \to }$  ( 6 5 8 2 1 9 )

Segunda vuelta: ( 6 5 8 2 1 9 ) ${\displaystyle \to }$  ( 5 6 8 2 1 9 ) ( 5 6 8 2 1 9 ) ${\displaystyle \to }$  ( 5 6 8 2 1 9 ), como estos elementos ya están en orden, el algoritmo no hace cambios. ( 5 6 8 2 1 9 ) ${\displaystyle \to }$  ( 5 6 2 8 1 9 ) ( 5 6 2 8 1 9 ) ${\displaystyle \to }$  ( 5 6 2 1 8 9 ) ( 5 6 2 1 8 9 ) ${\displaystyle \to }$  ( 5 6 2 1 8 9 )

Tercera vuelta: ( 5 6 2 1 8 9 ) ${\displaystyle \to }$  ( 5 6 2 1 8 9 ) ( 5 6 2 1 8 9 ) ${\displaystyle \to }$  ( 5 2 6 1 8 9 ) ( 5 2 6 1 8 9 ) ${\displaystyle \to }$  ( 5 2 1 6 8 9 ) ( 5 2 1 6 8 9 ) ${\displaystyle \to }$  ( 5 2 1 6 8 9 ) ( 5 2 1 6 8 9 ) ${\displaystyle \to }$  ( 5 2 1 6 8 9 )

Cuarta vuelta: ( 5 2 1 6 8 9 ) ${\displaystyle \to }$  ( 2 5 1 6 8 9 ) ( 2 5 1 6 8 9 ) ${\displaystyle \to }$  ( 2 1 5 6 8 9 ) ( 2 1 5 6 8 9 ) ${\displaystyle \to }$  ( 2 1 5 6 8 9 ) ( 2 1 5 6 8 9 ) ${\displaystyle \to }$  ( 2 1 5 6 8 9 ) ( 2 1 5 6 8 9 ) ${\displaystyle \to }$  ( 2 1 5 6 8 9 )

Quinta vuelta: ( 2 1 5 6 8 9 ) ${\displaystyle \to }$  ( 1 2 5 6 8 9 ) ( 1 2 5 6 8 9 ) ${\displaystyle \to }$  ( 1 2 5 6 8 9 ) ( 1 2 5 6 8 9 ) ${\displaystyle \to }$  ( 1 2 5 6 8 9 ) ( 1 2 5 6 8 9 ) ${\displaystyle \to }$  ( 1 2 5 6 8 9 ) ( 1 2 5 6 8 9 ) ${\displaystyle \to }$  ( 1 2 5 6 8 9 )

Ejemplo en C++

Este es un ejemplo de un programa que captura números y los ordena de menor a mayor en lenguaje C++, compilado con g++ 5.4.0:

#include<iostream> using namespace std; int main() { int num, aux; int comparaciones = 0; int intercambios = 0; int* arreglo; cout << "Cuantos numeros seran: "; cin >> num; arreglo = new int[num]; cout << endl << "***CAPTURA DE NUMEROS***" << endl; for(int x = 0; x < num; x++) { cout << "Ingresa el numero " << x << " de la serie: "; cin >> arreglo[x]; cout << endl; } cout << "***MUESTRA DE NUMEROS***" << endl; for(int y = 0; y < num; y++) { cout << "Numero " << y << ".- " << arreglo[y] << endl; } for(int z = 1; z < num; ++z) { for(int v = 0; v < (num - z); v++) { comparaciones++; if(arreglo[v] > arreglo[v+1]){  aux = arreglo[v];  arreglo[v] = arreglo[v + 1];  arreglo[v + 1] = aux;  intercambios++; } } } cout << "***NUMEROS ARREGLADOS***" << endl; for(int w = 0; w < num; w++) { cout << "Numero " << w << ".- " << arreglo[w] << endl; } cout << "Numero de comparaciones: " << comparaciones << endl; cout << "Numero de intercambios: " << intercambios << endl; delete[] arreglo; return 0; } 

Ejemplo en Python3

def bubbleSort(array): n = len(array) for i in range(n): for j in range(0, n-1):  if array[j] > array[j+1]:  array[j], array[j+1] = array[j+1], array[j] array = [200 ,190, 1200, 1, 2, 4, 55, 1000, 6, 800] bubbleSort(array) print(array) 

Referencias

1. Astrachan, Owen (2003). «Ordenamiento de burbuja: Un anális arqueológico de un algoritmo». SIGCSE (en inglés). Consultado el 9 de marzo de 2011. 
2. Knuth, Donald (1998). «5.2.2: Ordenamiento por intercambio». El arte de programar ordenadores, Volumen 3 (en inglés) (segunda edición). Addison-Wesley. pp. 106-110. ISBN 0-201-89685-0.  |fechaacceso= requiere |url= (ayuda)

Véase también

• Algoritmo de ordenamiento

Enlaces externos

• Implementaciones del algoritmo en Wikibooks (inglés)
• Distintas implementaciones del algoritmo en RosettaCode.org
• Implementación del algoritmo Bubblesort en Javascript (en español)

•   Datos: Q60864
•   Multimedia: Bubble sort