Ordenación de burbuja
La Ordenación de burbuja 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.
Representación animada del ordenación de burbuja :
Representación animada del ordenación de burbuja
PROCEDIMIENTO bubble_sort ( vector a[ 1 : n] )
iteración ← 0
REPETIR
permut ← FALSO
PARA i VARIANDO DE 1 HASTA n - 1 - iteración HACER
SI a[ i] > a[ i+ 1 ] ENTONCES
intercambiar a[ i] Y a[ i+ 1 ]
permut ← VERDADERO
FIN SI
FIN PARA
iteración ← iteración + 1
MIENTRAS QUE permut = VERDADERO
let bubble_sort vector =
let iteración= ref 1 and permutation = ref true in
while ( ! permutation = true ) do
permutation := false ;
iteración := ! iteración + 1 ;
for actual
= 0 to ( Array . length vector
) - ! iteración
do
if vector. ( actual) > vector. ( actual + 1 ) then
begin
(* Intercambiamos los dos elementos *)
permutation := true ;
let temp = vector. ( actual) in
begin
vector. ( actual) <- vector. ( actual + 1 ) ;
vector. ( actual + 1 ) <- temp;
end
end
done ;
done ;
vector;;
type tab = array [ 1 ..20 ] of integer ;
PROCEDIMIENTO bubble_sort( var vector : tab) ;
var permutation : boolean ;
actual : integer ;
temp : integer ;
iteración : integer ;
begin
iteración := 1 ;
REPEAT
permutation := false ;
for actual := 1 to 20 - iteración do
begin
if ( vector[ actual] > vector[ actual + 1 ] ) then
begin
{ Intercambiamos los dos elementos }
temp := vector[ actual] ;
vector[ actual] := vector[ actual + 1 ] ;
vector[ actual + 1 ] := temp;
permutation := true ;
end ;
end ;
iteración := iteración + 1 ;
UNTIL ( not permutation) ;
end ;
def bubble_sort( vector) :
permutation = True
iteración = 0
while permutation == True :
permutation = False
iteración = iteración + 1
for actual in range ( 0 , len ( vector) - iteración) :
if vector[ actual] > vector[ actual + 1 ] :
permutation = True
# Intercambiamos los dos elementos
vector[ actual] , vector[ actual + 1 ] = \
vector[ actual + 1 ] ,vector[ actual]
return vector
void bubble_sort( int * vector)
{
int iteración = 0 ;
bool permutation = true ;
int actual;
while ( permutation) {
permutation = false ;
iteración ++;
for ( actual= 0 ; actual< 20 - iteración; actual++ ) {
if ( vector[ actual] > vector[ actual+ 1 ] ) {
permutation = true ;
// Intercambiamos los dos elementos
int temp = vector[ actual] ;
vector[ actual] = vector[ actual+ 1 ] ;
vector[ actual+ 1 ] = temp;
}
}
}
}
Use este algoritmo para resolver el pequeño conjunto de la página anterior :
Comparaciones :
Movimientos :
Mezclar
Resolver
Los siguientes gráficos muestran el aumento en el número de transacciones en relación con el número de elementos a ser ordenados.
Rendimiento del algoritmo
En el caso óptimo, con los datos ya ordenados, el algoritmo sólo effectura n comparaciones. Por lo tanto la complejidad en el caso óptimo es en Θ(n ).
Rendimiento en el caso óptimo
Número de operaciones
Número de términos
Θ(n)
En el caso desfavorable, con los datos ordenados a la inversa, la complejidad es en Θ(n 2 ).
Rendimiento en el caso desfavorable
Número de operaciones
Número de términos
Θ(n2)
En el caso medio, la complejidad de este algoritmo es también en Θ(n 2 )
Rendimiento en el caso medio
Número de operaciones
Número de términos
Θ(n2)
Hay variantes interesantes del ordenamiento de burbuja como el Shaker sort , el ordonamiento de Oyelami o el Comb sort .