BUBBLE SORT

Lic. M.Sc. Benjamn H. Buitrago Conde

Introduccin
El Ordenamiento de Burbujeo (Bubble Sort en ingls) es un sencillo
algoritmo de ordenamiento. Funciona revisando cada elemento de la
lista que va a ser ordenada con el siguiente, intercambindolos de
posicin si estn en el orden equivocado. Es necesario revisar varias veces
toda la lista hasta que no se necesiten ms 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 pequeas "burbujas". Tambin es conocido como el
mtodo del intercambio directo.

Dado que solo usa comparaciones para operar elementos, se lo considera

un algoritmo de comparacin, siendo el ms sencillo de implementar.
Objetivo
Se implementara el Mtodo de
Ordenamiento de Burbujeo, utilizando
listas dinmicas.
Desarrollo
El ordenamiento de burbuja tiene una complejidad O(n).
Cuando una lista ya est ordenada, a diferencia del
ordenamiento por insercin que pasar por la lista una vez,
y encontrar que no hay necesidad de intercambiar las
posiciones de los elementos, el mtodo de ordenacin por
burbuja esta forzado a pasar por dichas comparaciones, lo
que hace que su complejidad sea cuadrtica en el mejor de
los casos, esto lo cataloga como el algoritmo ms
ineficiente que existe aunque para muchos programadores
sea el ms sencillo de implementar.
Bubble Sort 1
procedimiento Bubble_Sort1 (v[] de enteros, n es entero)
Variables
i, j, aux son enteros
Para i=0 hasta n-2
Para j = i+1 hasta n-1
Si (v[i] > v[j])
aux = v[i]
v[i] = v[j]
v[j]=aux
Fin_si
Fin_para
Fin_para
Fin_procedimiento
Bubble Sort 2
procedimiento Bubble_Sort2 (v[] de enteros, n es entero)
Variables
i, j, aux son enteros
Para i=1 hasta n-1
Para j = 0 hasta (n-1)-i
Si (v[j] > v[j+1])
aux = v[j]
v[j] = v[j+1]
v[j+1]=aux
Fin_si
Fin_para
Fin_para
Fin_procedimiento
TAD LISTA : recupera()
Mtodo recupera : Permite recuperar el elemento que ocupa un nodo de acuerdo a
su posicin

public int recupera(int posicion)

{
int c = 0;
nodo paux = cabeza;
while ((c != posicion) && (paux != null))
{
c = c + 1;
paux = paux.sig;
}
if (c == posicion)
return (paux.dato);
else
return (-1);
}
TAD LISTA : reemplaza()
Mtodo reemplaza : Permite modificar el elemento de un nodo de acuerdo a su
posicin

public void reemplaza(int posicion, int dato)

{
int c = 0;
nodo paux = cabeza;
while ((c != posicion) && (paux != null))
{
c = c + 1;
paux = paux.Sig;
}
if (c == posicion)
paux.dato = dato;
}
TAD LISTA : cuenta()
Mtodo cuenta : Permite contar el numero de nodos que tiene la lista.

public int cuenta()

{
int c = 0;
nodo paux = cabeza;
while (paux != null)
{
c = c + 1;
paux = paux.Sig;
}
return (c);
}
TAD LISTA : bubble_sort1()
public void bubble_sort1()
{
int i, j, aux;
for (i = 0; i <= cuenta() - 2; i++)
for (j = i; j <= cuenta() - 1; j++)
if (recupera(i) > recupera(j))
{
aux = recupera(i);
reemplaza(i, recupera(j));
reemplaza(j, aux);
}
}
TAD LISTA : bubble_sort2()
public void bubble_sort2()
{
int i, j, aux;
for (i = 1; i <= cuenta()-1; i++)
for (j = 0; j <= (cuenta()-1) - i; j++)
if (recupera(j) > recupera(j + 1))
{
aux = recupera(j);
reemplaza(j, recupera(j + 1));
reemplaza(j + 1, aux);
}
}
Conclusiones
El ordenamiento por burbujeo es uno de los mtodos de
ordenamiento ms fciles de implementar, sin embargo su
orden de complejidad lo hace el ms ineficiente.

Se ha implementado el algoritmo de burbujeo con listas

dinmicas que han logrado una mejor administracin de
memoria, sin embargo es necesario explorar otros mtodos
de ordenamiento que hagan del proceso de ordenamiento
ms eficiente en tiempo de ejecucin.
Bibliografa
http://es.wikipedia.org/wiki/Bubblesort