LOS J A C K ER S
Responsables del Contenido:
• Fabián Flores
• David Marín
• Jefferson Romo
"El Desarrollo Es Lo Nuestro, Y Lo Tuyo Contratarnos"
Tema: ALGORITMO DE ORDENAMIENTO BURBUJA
Introducción
Una tabla o un archivo es un grupo de elementos, cada uno de los cuales se llama
registro. Hay una llave asociada a cada registro, que se usa para diferenciar unos de
otros. La asociación entre un registro y su llave puede ser simple o compleja. En la
forma más simple, la llave esta contenida dentro del registro en un tramo a una
distancia especifica del principio del mismo. Una llave de ese tipo es la llave interna o
incluida.
Un algoritmo de búsqueda es un algoritmo que acepta un argumento a y trata de
encontrar un registro cuya llave sea a. El algoritmo puede dar como resultado el
registro entero o, lo que es más común, un apuntador a dicho registro.
Si la búsqueda es infructuosa, con mucha frecuencia, es deseable agregar un
nuevo registro con dicho argumento como llave. Un algoritmo que haga esto se le
llama tabla búsqueda o diccionario.
La búsqueda en la cual toda la tabla esta de manera frecuente en la memoria
principal se le llama búsqueda interna, mientras que la busqueda en la que la mayor
parte de la tabla esta en la memoria auxiliar se llama busqueda externa.
Descripción
Este es el algoritmo más sencillo probablemente. Ideal para empezar. Consiste en
ciclar repetidamente a través de la lista, comparando elementos adyacentes de dos en
dos. Si un elemento es mayor que el que está en la siguiente posición se intercambian.
Una manera simple de expresar el ordenamiento de burbuja en pseudocódigo es la
siguiente:
Algoritmo Ordenamiento de burbuja
Procedimiento
Haga lo siguiente:
Para hasta haga lo siguiente:
Si entonces:
Repita mientras
La instrucción significa que se debe intercambiar el valor de
con el de . El algoritmo también puede ser expresado de manera equivalente
como sigue:
Algoritmo Ordenamiento de burbuja
Procedimiento
Para hasta haga lo siguiente:
Para hasta haga lo siguiente:
Si entonces:
Notar que:
• Se supone que los vectores que se están ordenando empiezan en la posición
cero (0) y terminan en la posición n − 1.
• El ordenamiento se hace de menor a mayor, si se quisiera hacer al revés
bastaría con cambiar el sentido de la comparación en las sentencias si de cada
algoritmo, es decir, donde pone '>' poner '<'.
Entonces:
Dado un vector a1, a2, a3, ... an
1) Comparar a1 con a2 e intercambiarlos si a1>a2 (o a12)
2) Seguir hasta que todo se haya comparado an-1 con an
3) Repetir el proceso anterior n-1 veces
Algoritmo: Complejidad
for(i=0; i < n-1; i++){ T(n2)
for(j=0; j < n-1; j++){ T(n)
if(vec[j] > vec[j+1]){ T(1)
aux=vec[j]; T(1)
vec[j]=vec[j+1]; T(1)
vec[j+1]=aux;} T(1)
}
}
El procedimiento de la burbuja es el siguiente:
Ir comparando desde la casilla 0 numero tras número hasta encontrar uno
mayor, si este es realmente el mayor de todo el vector se llevará hasta la
última casilla, si no es así, será reemplazado por uno mayor que él.
Este procedimiento seguirá así hasta que halla ordenado todas las casillas del
vector.
Una de las deficiencias del algoritmo es que ya cuando a ordenado parte del
vector vuelve a compararlo cuando esto ya no es necesario.
Ejemplo:
Vector
Variables
pos 0 1 2 3 4 5 6 7
i j a[j] a[j+1] inicio 44 55 12 42 94 18 6 67
0 1 55 12 cambio 44 12 55 42 94 18 6 67
0 2 55 42 cambio 44 12 42 55 94 18 6 67
0 4 94 18 cambio 44 12 42 55 18 94 6 67
0 5 94 6 cambio 44 12 42 55 18 6 94 67
0 6 94 67 cambio 44 12 42 55 18 6 67 94
1 0 44 12 cambio 12 44 42 55 18 6 67 94
1 1 44 42 cambio 12 42 44 55 18 6 67 94
1 3 55 18 cambio 2 42 44 18 55 6 67 94
1 4 55 6 cambio 12 42 44 18 6 55 67 94
2 2 44 18 cambio 12 42 18 44 6 55 67 94
2 3 44 6 cambio 12 42 18 6 44 55 67 94
3 1 42 18 cambio 12 18 42 6 44 55 67 94
3 2 42 6 cambio 12 18 6 42 44 55 67 94
4 1 18 6 cambio 12 6 18 42 44 55 67 94
5 0 12 6 ordenado 6 12 18 42 44 55 67 94
RIMERA MEJORA DEL METODO DE LA BURBUJA
La primera "pasada" a lo largo del vector deja el número mayor en el extremo
derecho. La segunda pasada deja los dos números mayores ordenados en el extremo
derecho, y así hasta quedar el vector ordenado ascendentemente..
A comparación con el método de la burbuja que compara parte del vector cuando ya
esta ordenado, este no lo hace ya que ahora tiene el límite para no llegar a comparar a
donde ya ordeno.
Algoritmo (Orientado a C) Complejidad
for (i=0; i < n-1; j++){ T(n2)
for (j=0; j < (n-1)-i; j++){ T(n)
if (a(j) > a(j+1) ){ T(1)
aux = a(j); T(1)
a(j) = a(j+1); T(1)
a(j+1) = aux; T(1)
}
}
}
Ejemplo:
Este ejemplo muestra las condiciones en las que se encontraron las variables
cuando se hicieron los respectivos cambios
Vector
Variables
pos 0 1 2 3 4 5 6 7
i j a[j] a[j+1] inicio 44 55 12 42 94 18 6 67
0 0 44 55
1 55 12 cambio 44 55 12 42 94 18 6 67
2 55 42 cambio 44 12 55 42 94 18 6 67
3 55 94
4 94 18 cambio 44 12 42 55 94 18 6 67
5 94 6 cambio 44 12 42 55 18 94 6 67
6 94 67 cambio 44 12 42 55 18 6 94 67
7
1 0 44 12 cambio 44 12 42 55 18 6 67 94
1 44 42 cambio 12 44 42 55 18 6 67 94
2 44 55
3 55 18 cambio 2 42 44 55 18 6 67 94
4 55 6 cambio 12 42 44 18 55 6 67 94
5 55 67
6
2 0 12 42
1 42 44
2 44 18 cambio 12 42 44 18 6 55 67 94
3 44 6 cambio 12 42 18 44 6 55 67 94
4 44 6
5
3 0 12 42
1 42 18 cambio 12 42 18 6 44 55 67 94
2 42 6 cambio 12 18 42 6 44 55 67 94
3 42 44
4
4 0 12 18
1 18 6 cambio 12 18 6 42 44 55 67 94
2 18 42
3
5 0 12 6 Ordenado 12 6 18 42 44 55 67 94
1 12 18
2
6 0 6 12
1 ordenado 6 12 18 42 44 55 67 94
Análisis
Rendimiento en casos óptimos
El ordenamiento de burbuja tiene una complejidad Ω(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 esta 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 el algoritmo mas ineficiente que existe aunque para muchos programadores sea
el más sencillo de implementar.
Implementaciones en distintos lenguajes de programación.
A Continuación se verán implementaciones del algoritmo de ordenamiento de burbuja
en distintos lenguajes de programación
Visual Basic for Applications
Sub ORDENAR()
Dim X As Integer
Dim I As Integer
Dim y As Double
Dim j As Integer
X=1
For I = 1 To 10
Cells(I, 1) = Rnd
Next I
For I = 1 To 9
For j = I + 1 To 10
If Cells(I, 1) < Cells(j, 1) Then
y = Cells(j, 1)
Cells(j, 1) = Cells(I, 1)
Cells(I, 1) = y
End If
Next j
Next I
End Sub
Visual Basic .NET
Module Burbuja
" Con Este algoritmo podras ordenar un conjunto de números que esten dentro de un
vector de menor a mayor e imprimirlos al final "
( Es una aplicacion de consola como veran )
Sub Main()
Dim i, v(10), j, aux As Integer
'''Se dimencionan las variables i y j para los ciclos repetitivos ( for)
y el vector v con que va a contener 10 posiciones V(10) y la variable aux que nos
servira como auxiliar para el intercambio de valores '.''
For i = 1 To 10
Console.WriteLine(" Digite Un numero para la casilla " & i & " del vector :")
v(i) = Console.ReadLine
Next
For i = 1 To 10
For j = i To 10 - 1
If v(j) > v(j + 1) Then
aux = v(j)
v(j) = v(j + 1)
v(j + 1) = aux
End If
Next
Next
For i = 1 To 10
Console.WriteLine(v(i))
Next
Console.ReadLine()
End Sub
End Module
esta es otra forma utilizando getlength:
For ancla = 0 To vector.GetLength(0) - 2 Step 1
For burbu = ancla + 1 To vector.GetLength(0) - 1 Step 1
If vector(ancla) > vector(burbu) Then
aux = vector(burbu)
vector(burbu) = vector(ancla)
vector(ancla) = aux
End If
Next
Next
Call mostrar(vector)
End If
End Sub
Public Sub mostrar(ByVal W() As Integer)
For tama = 1 To W.GetLength(0) - 1
ordenados.Items.Add(W(tama).ToString)
Next
End Sub
Este ordenamiento es ascendente. Para hacerlo descendente, en vez del vector(ancla)
">" vector(burbu) es "<".
C
void bubble(int *start, int *end) { //Ordena un conjunto de números enteros de menor
a mayor
short fin;
do{
fin = 0;
for(int *i = start; i != *end; i++){
if(*i > *(i+1)){
intercambia(i, i + 1);
fin = 1;
}
}
}while(fin);
}
Lenguaje C++
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#define TAM 10
int main(){
int a[TAM], temp, i, j;
clrscr();
randomize(); //Inicializa el generador de números aleatorios
printf ("Llenando arreglo con números aleatorios\n");
for (i=0; i< TAM; i++)
a[i]=random(100);
//Implementacion de Ordenamiento por burbuja de mayor a menor
for (j=1; j <= TAM; j++)
for (i=0; i< TAM-1; i++)
if (a[i] > a[i+1]){
temp = a[i];
a[i] = a[i+1];
a[i+1] = temp;
}
printf ("\nArreglo ordenado\n");
for (i=0; i< TAM; i++)
printf ("a[%d] = %d\n", i, a[i]);
getch();
}
C (Ejemplo 2)
void bubble(int A[], int tamano_arreglo) //Ordena un arreglo de números enteros de
menor a mayor
{
int temp,temp2, j, i;
for(i = (tamano_arreglo-1); i >= 0; i--)
{
temp2= (tamano_arreglo-1);
for(j = 1; j <= temp2; j++)
{
if(A[j-1] > A[j])
{
/* Intercambio de numeros*/
temp = A[j-1];
A[j-1] = A[j];
A[j] = temp;
}
}
}
}
Python
def bubblesort(l):
"""Ordena la lista l y la devuelve."""
for pasosIzq in range(len(l)-1, 0, -1):
for indice in range(pasosIzq):
if l[indice] < l[indice + 1]:
l[indice], l[indice + 1] = l[indice + 1], l[indice]
return l
Java
//Método de la burbuja en los elementos de un vector.
import java.util.Random;
public class barbarscummBarLechuck!
{
public static void main ( String args [])
{
Random nA = new Random();
int X[] = new int [10];
int i, j, aux;
System.out.println("----------***** NÚMEROS GENERADOS *****----------");
for (i = 0; i < X.length; i++)
{
X[i] = nA.nextInt(9)+1;
System.out.print( X[i]);
}
System.out.println("");
System.out.println("----------***** NÚMEROS ORDENADOS *****----------");
for (i = 0; i < X.length; i++)
{
for (j = 0; j < X.length-1; j++)
{
if (X[j] > X[j+1])
{
aux = X[j];
X[j] = X[j+1];
X[j+1] = aux;
}
}
}
for (i = 0; i < X.length; i++){
System.out.print(X[i]);
}
}
}
JavaScript
for (var i=1; i<Vector.length;i++)
{
for(var j=0;j<Vector.length-1;j++)
{
if (Vector[j] > Vector[j+1])
{
var temp = Vector[j];
Vector[j]= Vector[j+1];
Vector[j+1]= temp;
}
}
}
Perl
sub bubblesort {
# Ordena la lista pasada como argumento por valor
foreach my $i ( 0 .. @_-2 ) {
foreach my $j ( $i+1 .. @_-1 ) {
@_[ $i, $j ] = @_[ $j, $i ] if $_[$i] > $_[$j] }}
}
COBOL
PERFORM ORDENAR-TABLA
VARYING I FROM 1 BY 1
UNTIL I > (TAM - 1)
...
ORDENAR-TABLA.
PERFORM VARYING J FROM 1 BY 1 UNTIL J > (TAM - 1)
IF REGISTRO-NAME(J + 1) < REGISTRO-NAME(J)
MOVE REGISTRO(J) TO AUXILIAR
MOVE REGISTRO(J + 1) TO REGISTRO(J)
MOVE AUXILIAR TO REGISTRO(J + 1)
END-IF
END-PERFORM.
C#
int[] a = new int[]{1,4,6,8,9,0};
System.Console.WriteLine("Programa en C#");
for (int i = 0; i < a.Length; i++)
{
for (int j = 0; j < a.Length-1; j++)
{
if (a[j] > a[j+1])
{
int aux = a[j];
a[j] = a[j+1];
a[j+1] = aux;
}
}
}
System.Console.WriteLine("Ahora los Imprimo");
for (int i = 0; i < a.Length; i++)
{ System.Console.WriteLine("Valor {0}: {1}", i + 1, a[i]); }
PHP
function bubble_sort($array){
$count = count($array);
if ($count <= 0) return false;
for($i=0; $i<$count; $i++){
for($j=$count-1; $j>$i; $j=$j-1){
if ($array[$j] < $array[$j-1]){
$tmp = $array[$j];
$array[$j] = $array[$j-1];
$array[$j-1] = $tmp;
}
}
}
return $array;
}
Pascal
Procedure BubleSort(var sort:Array_integer);
Var
{n es la cantidad de posiciones del arreglo}
a,s,tmp:integer;
Begin
For a := 1 to n do
For s := a-1 to n-1 do
If (sort[s] > sort[s+1]) then
Begin
tmp:= sort[s];
sort[s] := sort[s+1];
sort[s+1] := tmp;
End;
End;
End;
Conclusiones:
El número de comparaciones en el método de la burbuja es fácilmente contabilizable.
Respecto al número de movimientos, éstos dependen de si el arreglo está ordenado,
desordenado o en orden inverso.
Bibliografía:
• H.M. Deitel, P.J. Deitel: "Cómo programar en C/C++". Editorial Prentice
Hall.
• Charles Bowman: "Algoritmos y estructuras de datos: Aproximación en
C". Oxford University Press, 1999.
• "Dictionary of Algorithms, Data Structures, and Problems"
