METODO BURBUJA DE ORDENACION

Este programa viene como respuesta a Juan Jose, que comentó en la entrada del Metodo de Gauss por este procedimiento, el Metodo de la burbuja..

El fin del método, es ordenar una serie de números, en un determinado orden, creciente o decreciente, comparando únicamente pares de números consecutivos. La comparación se realiza entre dos números consecutivos. Si lo que se ha elegido es ordenar de mayor a menor, y el segundo numero es mayor que el primero, el orden de estos se invertirá  pasando a estar primero el que estaba segundo (mayor) y segundo el que estaba primero. En el siguiente paso se comparan de igual modo el que estaba segundo(que anteriormente estaba primero) con el tercero, y se operara del mismo modo. Se repetirá este procedimiento hasta que no se lleve a cabo ningún cambio en la cedena, lo que asegurará que la cadena esta ordenada. esto se podría representar del siguiente modo:

Tenemos esta serie de números que queremos ordenar de menor a mayor, tal que A0 sea el menor y A4 el mayor:

Cadena inicial





Iteracion 1


ha habido cambios, luego se sigue.

Iteracion 2:

Ha habido cambios, luego se sigue (la pareja A4, A3 no hace falta compararla puesto que esta ordenada seguro)

Iteración 3:

Ha habido cambios, luego se sigue. (No se compara ni A2 con A3, ni A3 con A4)

Iteracion 4

No hay cambios luego no se sigue. Ya esta ordenada la cadena.

Un ejemplo de la salida del programa sería, el fichero de entrada seria el siguiente (¡OJO CON NO PONER ESPACIOS DESPUÉS DE CADA NUMERO, PORQUE SI NO EL PROGRAMA LEERA ESTOS HUECOS, LOS INTENTARA GUARDAR EN UNA VARIABLE DEL TIPO DATO Y DARA ERROR)

9
27
-10
0.01
40
-3
8


Y la salida del programa sera:

Iteración número1:

 2.700000000000000E+001
 9.000000000000000E+000
 1.000000000000000E-002
 4.000000000000000E+001
-3.000000000000000E+000
 8.000000000000000E+000
-1.000000000000000E+001



Iteración número2:

 2.700000000000000E+001
 9.000000000000000E+000
 4.000000000000000E+001
 1.000000000000000E-002
 8.000000000000000E+000
-3.000000000000000E+000
-1.000000000000000E+001



Iteración número3:

 2.700000000000000E+001
 4.000000000000000E+001
 9.000000000000000E+000
 8.000000000000000E+000
 1.000000000000000E-002
-3.000000000000000E+000
-1.000000000000000E+001



Iteración número4:

 4.000000000000000E+001
 2.700000000000000E+001
 9.000000000000000E+000
 8.000000000000000E+000
 1.000000000000000E-002
-3.000000000000000E+000
-1.000000000000000E+001



Iteración número5:

 4.000000000000000E+001
 2.700000000000000E+001
 9.000000000000000E+000
 8.000000000000000E+000
 1.000000000000000E-002
-3.000000000000000E+000
-1.000000000000000E+001

En esta última iteracion ya estan ordenados los numeros. (notacion cientifica).

El programa muestra un menu como el siguiente:




Despues de esta ejecucion, se habra creado un nuevo fichero de texto en la ubicacion desde donde se ejecute el prgrama, con el nombre respuesta y la cadena de numeros ordenada.

El codigo del programa es el siguiente:

program MetodoBurbuja (input,output);

const
  MAXNUM=1000;
type
  TpFichero=text;
  TpContador=0..MAXINT;
  TpNombre=string[40];
  TpDato=real;
  TpCadena=array[1..MAXNUM] of TpDato;
var
  Fichero:TpFichero; {Fichero donde se guardan los datos ordenados}
  Nombre:TpNombre;
  Cadena:TpCadena;
  Cambio:Boolean;
  NDatos,Opcion,Iteraciones,b:TpContador;

procedure CargaFichero(VAR Fich:TpFichero; VAR Nom:TpNombre; VAR Cad:TpCadena; VAR Op:TpContador; VAR N:TpContador);
  var
    Dato:TpDato;
    Fich2:TpFichero;
  begin
    writeln('ORDENA SERIE DE NUMEROS DISPUESTOS EN COLUMNA EN FICHERO DE TEXTO MEDIANTE EL');
    writeln('METODO DE LA BURBUJA, MOSTRANDO PARA ELLO TODAS LAS ITERACIONES Y EL NUMERO DE');
    writeln('LAS MISMAS, DE MENOR A MAYOR O DE MAYOR A MENOR'); writeln;
    write('Introduzca el nombre del fichero de texto a ordenar (SIN .TXT): ');readln(Nom);
    Nom:=Nom+('.txt');
    writeln;
    assign(Fich2,Nom);
    reset(Fich2);
    write('Introduzca el nombre del fichero de texto donde guardar los datos (SIN .TXT): ');readln(Nom);
    Nom:=Nom+('.txt');
    assign(Fich,Nom);
    rewrite(Fich);
    N:=0;
    while not eof(Fich2) do begin
      N:=N+1;
      readln(Fich2,Dato);
      Cad[N]:=Dato
    end;
    { 'N': Numero de Datos}
    Close(Fich2);
    writeln('Seleccione indicando el numero: ');
    writeln('1) Ordenar de Mayor a Menor: ');
    writeln('2) Ordenar de Menor a Mayor: ');
    readln(Op)
  end;


Procedure CambiaPosicion(j:TpContador;VAR Cad:TpCadena);
  var
    aux:tpDato;
  begin
    aux:=Cad[j];
    Cad[j]:=Cad[j+1];
    Cad[j+1]:=aux
  end;


Procedure GuardarIteracion(VAR Fich:TpFichero; Cad:TpCadena; j:TpContador);
  var
    i:TpContador;
  begin
    Writeln(Fich);
    Writeln(Fich,'Iteración número',j,':');
    Writeln(Fich);
    for i:=1 to NDatos do
      writeln(Fich,Cad[i]);
    Writeln(Fich);Writeln(Fich)
  end;




begin
  CargaFichero(Fichero,Nombre,Cadena,Opcion, NDatos);
  cambio:=true;
  Iteraciones:=0;
  If opcion=1 then
    while cambio do begin
      cambio:=false;
      for b:=1 to (NDatos-1-Iteraciones) do
        if cadena[b+1]> cadena[b] then begin
          CambiaPosicion(b,Cadena);
          Cambio:=true
        end;
      Iteraciones:=Iteraciones+1;
      GuardarIteracion(Fichero,Cadena,Iteraciones)
    end
  else if opcion=2 then
    while cambio do begin
      cambio:=false;
      for b:=1 to (NDatos-1-Iteraciones) do
        if cadena[b+1]< cadena[b] then begin
          CambiaPosicion(b,Cadena);
          Cambio:=true
        end;
      Iteraciones:=Iteraciones+1;
      GuardarIteracion(Fichero,Cadena,Iteraciones)
    end
  else writeln('No se ha escogido una opcion correcta');
  close(Fichero);
  readln
end.

La idea sería crear un código para que pudiera ordenar las componentes de una array de manera creciente y decreciente, según eligiera el usuario.

Espero que les sirva. Cualquier pregunta aquí estoy.

Salud!