LOS

J A C K ER S

Responsables del Contenido: Fabin Flores David Marn Jefferson Romo

"El Desarrollo Es Lo Nuestro, Y Lo Tuyo Contratarnos"

Tema: ALGORITMO DE ORDENAMIENTO BURBUJA

Introduccin 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 asociacin entre un registro y su llave puede ser simple o compleja. En la forma ms 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 bsqueda 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 ms comn, un apuntador a dicho registro. Si la bsqueda 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 bsqueda o diccionario. La bsqueda en la cual toda la tabla esta de manera frecuente en la memoria principal se le llama bsqueda interna, mientras que la busqueda en la que la mayor parte de la tabla esta en la memoria auxiliar se llama busqueda externa. Descripcin Este es el algoritmo ms sencillo probablemente. Ideal para empezar. Consiste en ciclar repetidamente a travs de la lista, comparando elementos adyacentes de dos en dos. Si un elemento es mayor que el que est en la siguiente posicin se intercambian. Una manera simple de expresar el ordenamiento de burbuja en pseudocdigo es la siguiente: Algoritmo Ordenamiento de burbuja Procedimiento Haga lo siguiente: Para Si hasta haga lo siguiente: entonces:

Repita mientras La instruccin con el de como sigue: significa que se debe intercambiar el valor de . El algoritmo tambin puede ser expresado de manera equivalente 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 estn ordenando empiezan en la posicin cero (0) y terminan en la posicin n 1. El ordenamiento se hace de menor a mayor, si se quisiera hacer al revs bastara con cambiar el sentido de la comparacin 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 nmero 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: Variables i 0 0 0 0 0 1 1 1 1 2 2 3 3 4 5 j 1 2 4 5 6 0 1 3 4 2 3 1 2 1 0 Vector pos a[j] a[j+1] inicio 55 55 94 94 94 44 44 55 55 44 44 42 42 18 12 12 42 18 6 67 12 42 18 6 18 6 18 6 6 6 cambio cambio cambio cambio cambio cambio cambio cambio cambio cambio cambio cambio cambio cambio 0 44 44 44 44 44 44 12 12 2 12 12 12 12 12 12 1 55 12 12 12 12 12 44 42 42 42 42 42 18 18 6 12 2 12 55 42 42 42 42 42 44 44 44 18 18 42 6 18 18 3 42 42 55 55 55 55 55 55 18 18 44 6 6 42 42 42 4 94 94 94 18 18 18 18 18 55 6 6 44 44 44 44 44 5 18 18 18 94 6 6 6 6 6 55 55 55 55 55 55 55 6 6 6 6 6 94 67 67 67 67 67 67 67 67 67 67 67 7 67 67 67 67 67 94 94 94 94 94 94 94 94 94 94 94

ordenado 6

RIMERA MEJORA DEL METODO DE LA BURBUJA La primera "pasada" a lo largo del vector deja el nmero mayor en el extremo derecho. La segunda pasada deja los dos nmeros mayores ordenados en el extremo derecho, y as hasta quedar el vector ordenado ascendentemente.. A comparacin con el mtodo de la burbuja que compara parte del vector cuando ya esta ordenado, este no lo hace ya que ahora tiene el lmite 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
Variables i j 1 2 3 4 5 6 7 1 0 1 2 3 4 5 6 2 0 1 2 3 4 5 3 0 1 2 3 12 42 42 42 42 18 6 44 cambio cambio 12 42 18 6 44 12 18 42 6 44 55 55 67 94 67 94 12 42 44 44 44 42 44 18 6 6 cambio cambio 12 42 44 18 6 12 42 18 44 6 55 55 67 94 67 94 44 44 44 55 55 55 12 42 55 18 6 67 cambio cambio 2 42 44 55 18 12 42 44 18 55 6 6 67 94 67 94 cambio cambio 44 12 42 55 18 12 44 42 55 18 6 6 67 94 67 94 a[j] 44 55 55 55 94 94 94 Vector pos a[j+1] 55 12 42 94 18 6 67 cambio cambio cambio 44 12 42 55 94 44 12 42 55 18 44 12 42 55 18 18 94 6 6 67 6 67 94 67 cambio cambio 44 55 12 42 94 44 12 55 42 94 18 18 6 67 6 67 inicio 0 1 2 3 4 5 18 6 7 44 55 12 42 94 6 67

0 0

4 4 0 1 2 3 5 0 1 2 6 0 1 6 12 ordenado 6 12 18 42 44 55 67 94 12 12 6 18 Ordenado 12 6 18 42 44 55 67 94 12 18 18 18 6 42 cambio 12 18 6 42 44 55 67 94

Anlisis Rendimiento en casos ptimos El ordenamiento de burbuja tiene una complejidad (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 mas ineficiente que existe aunque para muchos programadores sea el ms sencillo de implementar. Implementaciones en distintos lenguajes de programacin. A Continuacin se vern implementaciones del algoritmo de ordenamiento de burbuja en distintos lenguajes de programacin 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 nmeros 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 nmeros 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 nmeros aleatorios printf ("Llenando arreglo con nmeros 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 nmeros 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 //Mtodo 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("----------***** NMEROS 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("----------***** NMEROS 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 nmero de comparaciones en el mtodo de la burbuja es fcilmente contabilizable. Respecto al nmero de movimientos, stos dependen de si el arreglo est ordenado, desordenado o en orden inverso. Bibliografa:

H.M. Deitel, P.J. Deitel: "Cmo programar en C/C++". Editorial Prentice Hall. Charles Bowman: "Algoritmos y estructuras de datos: Aproximacin en C". Oxford University Press, 1999. "Dictionary of Algorithms, Data Structures, and Problems"