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"