Ordenación por intercambio o burbuja
El método de ordenación por burbuja se basa en comparaciones sucesivas de dos elementos consecutivos y realizar un intercambio entre los elementos hasta que queden ordenados.
Supongamos el vector mostrado en la siguiente tabla, para realizar la ordenación se han de seguir estos pasos:
- Se comparan los dos primeros elementos, si el segundo es superior al primero, se dejan tal como están, pero si el primero es el más grande, se intercambian los elementos.
- A continuación se compara el segundo elemento con el tercero aplicando los mismos criterios del paso anterior.
- De esta forma se repite la operación de comparación con todos los elementos que forman el vector. Cuando se alcance el último elemento se ha encontrado el elemento que tiene el valor más elevado y este ha quedado situado al final del vector.
- Para encontrar el segundo elemento se repite la operación de ordenación de todos los elementos del vector excepto con el último.
- Reiterando el proceso descrito, el vector quedará ordenado cuando solo se comparen los dos primeros elementos.
Primera ordenación.
Ejemplo de ordenación por burbuja para encontrar el primer elemento.
| Vector | 1ª Comparación | 2ª Comparación | 3ª Comparación | 4ª Comparación | 5ª Comparación |
V[1] | 3 | 3 | 3 | 3 | 3 | 3 |
V[2] | 34 | 34 | 1 | 1 | 1 | 1 |
V[3] | 1 | 1 | 34 | 34 | 34 | 34 |
V[4] | 53 | 53 | 53 | 53 | 15 | 15 |
V[5] | 15 | 15 | 15 | 15 | 53 | 6 |
V[6] | 6 | 6 | 6 | 6 | 6 | 53 |
El proceso de ordenación expresado en pseudocódigo estructurado es:
desde j ← 1 hasta n-1 hacer
si elemento[j] > elemento[j+1] entonces
intercambiar(elemento[j], elemento[j+1])
fin_si
fin_desde
Para el proceso de intercambiar los elementos se ha de utilizar una variable auxiliar de la siguiente forma:
aux ← V[j]
V[j] ← V[j+1]
V[j+1] ← aux
Segunda ordenación.
| Vector | 1ª Ordenación | 1ª Comparación | 2ª Comparación | 3ª Comparación | 4ª Comparación |
V[1] | 3 | 3 | 1 | 1 | 1 | 1 |
V[2] | 34 | 1 | 3 | 3 | 3 | 3 |
V[3] | 1 | 34 | 34 | 34 | 15 | 15 |
V[4] | 53 | 15 | 15 | 15 | 34 | 6 |
V[5] | 15 | 6 | 6 | 6 | 6 | 34 |
V[6] | 6 | 53 | 53 | 53 | 53 | 53 |
Después de la segunda ordenación se han encontrado los dos elementos más grandes del vector y estos se han situado al final del mismo.
Algoritmo de burbuja.
Generalizando el proceso de ordenación se obtine el siguiente pseudocódigo estructurado para el algoritmo de burbuja.
i - Variable ordenaciones
j - Variable comparaciones
n - Número de elementos del vector (en C representa el índice mayor)
algoritmo Burbuja
inicio
// Ordenaciones
desde i ← 1 hasta n-1 hacer
// Comparaciones
desde j ← 1 hasta n-i hacer
si elemento[j] > elemento[j+1] entonces
// Intercambiar los elementos
aux ← V[j]
V[j] ← V[j+1]
V[j+1] ← aux
fin_si
fin_desde
fin_desde
fin
Ejemplo en C:
int v[]={3, 34, 1, 53, 15, 6};
int j,i, aux;
// Ordenación
for(i=0; i<5; i++){
// Comparaciones
for(j=0; j<5-i; j++){
// Intercambiar los elementos
if(v[j] > v[j+1]){
aux=v[j];
v[j]=v[j+1];
v[j+1]=aux;
}
}
}
Reiterando en las ordenaciones obtenemos el vector ordenado tal como se muestra en la siguiente tabla:
| Vector | 1ª Ordenación | 2ª Ordenación | 3ª Ordenación | 4ª Ordenación | 5ª Ordenación |
V[1] | 3 | 3 | 1 | 1 | 1
| 1 |
V[2] | 34 | 1 | 3 | 3 | 3 | 3 |
V[3] | 1 | 34 | 15 | 6 | 6 | 6 |
V[4] | 53 | 15 | 6 | 15 | 15 | 15 |
V[5] | 15 | 6 | 34 | 34 | 34 | 34 |
V[6] | 6 | 53 | 53 | 53 | 53 | 53 |
Método de ordenación de burbuja mejorado.
Si nos fijamos en la tabla de ordenaciones observamos que el vector ha quedado ordenado en la tercera ordenación, siendo innecesario realizar la cuarta y la quinta ordenación, sin embargo el algoritmo de burbuja analizado realiza todas las comparaciones de las ordenaciones hasta (n-1). Se puede detectar que el vector se encuentra ordenado e interrumpir las ordenaciones, de esta forma mejoramos el rendimiento del algoritmo. Cuando se realiza una ordenación si en todas las comparaciones no se ha realizado un intercambio de elementos es debido a que el vector se encuentra ordenado. Se puede utilizar un indicador, bandera o variable booleana para detectar el fin de la ordenación.
El siguiente algoritmo muestra una de las versiones optimizada del método de ordenación por burbuja.
i - Variable ordenaciones
j - Variable comparaciones
n - Número de elementos del vector (en C representa el índice mayor)
ord - Variable indicadora de vector ordenado
algoritmo Burbuja2
inicio
// Ordenaciones
i ← 1 // Iniciar ordenaciones
ord ← 0 // Iniciar indicador de vector ordenado
mientras ord = 0 hacer
ord ← 1
// Comparaciones
desde j ← 1 hasta n-i hacer
si elemento[j] > elemento[j+1] entonces
// Intercambiar los elementos
aux ← V[j]
V[j] ← V[j+1]
V[j+1] ← aux
ord ← 0
fin_si
fin_desde
i ← i+1
fin_mientras
fin
Ejemplo en C:
int v[]={3, 34, 1, 53, 15, 6};
int j, aux;
int i = 0;
bool ord = false;
// Ordenaciones
while(!ord){
// Comparaciones
ord=true;
for(j=0;j<5-i;j++){
if(v[j]>v[j+1]){
// Intercambiar los elementos
aux=v[j];
v[j]=v[j+1];
v[j+1]=aux;
ord = false; // Indicador de vector ordenado
}
}
i++;
}
El ejemplo en C++ Builder:
//---------------------------------------------------------------------------
#include <vcl.h>
#include <iostream.h>
#include <conio.h>
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
int main(int argc, char* argv[]){
// Variables
int v[]={3, 34, 1, 53, 15, 6};
int j, aux;
int i = 0;
bool ord = false;
// Visualizar el vector
for(int n=0; n<6; n++){
cout << v[n] << " ";
}
// Ordenaciones
while(!ord){
// Comparaciones
ord=true;
for(j=0;j<5-i;j++){
if(v[j]>v[j+1]){
// Intercambiar los elementos
aux=v[j];
v[j]=v[j+1];
v[j+1]=aux;
ord = false; // Indicador de vector ordenado
}
}
i++;
}
// Visualizar el vector ordenado
cout << endl;
for(int n=0; n<6; n++){
cout << v[n] << " ";
}
getch();
return 0;
}
//---------------------------------------------------------------------------
Muchos autores critican el método de ordenación por burbuja debido a su bajo rendimiento y a su desmerecida relevancia, aunque comparto estas opiniones, se trata de un sistema muy sencillo que se adapta perfectamente para su estudio en centros de formación.
Otros métodos de ordenación como Selección o Inserción proporcionan mejores resultados, los sistemas de ordenación Rápido (quicksort), Shell y Merge son los más eficaces, proporcionando unos rendimientos espectaculares cuando se trata de ordenar vectores de grandes dimensiones.