Versión en video (12:47 min):

Pascal

13. Arrays (2: algoritmos habituales)

(En revisión)

13.1. Buscar en un array

Buscar en un array "tiene truco": si el elemento que estamos mirando contiene el dato que buscábamos, sabremos con seguridad que el dato existía, pero, por el contrario, no podremos afirmar que un dato no existe hasta que no hayamos comprobado todos los elementos. Por eso, lo habitual es usar un "boolean" para memorizar si lo hemos encontrado o no:

(* ARRAYB.PAS, Buscar en un array     *)
(* Curso de Pascal, por Nacho Cabanes *)

program ArrayB;

var
    datos: array[1..5] of integer;
    i: integer;
    encontrado: boolean;

begin
    for i := 1 to 5 do
    begin
        write('Deme el dato ',i,': ');
        readLn(datos[i]);
    end;

    encontrado := false;
    write('Buscando un 10... ');
    for i := 1 to 5 do
        if datos[i] = 10 then encontrado := true;

    if encontrado then
        writeLn('Encontrado!');
    else
        writeLn('No encontrado.');
end.

13.2. Máximo y mínimo de un array

No es difícil encontrar el valor máximo o el mínimo de un array. Debemos empezar con un máximo (o mínimo) provisional, que puede ser el primer valor del array. A partir de ese punto, vamos comparando uno a uno con todos los demás datos. Si el dato actual es mayor que el máximo (o menor que el mínimo), pasará a ser nuestro nuevo máximo (o mínimo), que deberemos memorizar.

(* ARRAYMAX.PAS, Maximo valor en un array *)
(* Curso de Pascal, por Nacho Cabanes     *)

program ArrayMax;

var
    datos: array[1..6] of integer;
    i: integer;
    maximo: integer;

begin
    datos[1] := 20;
    datos[2] := 12;
    datos[3] := 7;
    datos[4] := 35;
    datos[5] := 48;
    datos[6] := 14;

    maximo := datos[1];
    for i := 2 to 6 do
        if datos[i] > maximo then
            maximo := datos[i];

    writeLn('El maximo es: ', maximo);
end.

(* Resultado:
El maximo es: 48
*)

13.3. Ordenar los datos de un array

¿Y si necesitamos ordenar los datos de menor a mayor, o de mayor a menor, o (pronto) alfabéticamente? Hay muchas formas de hacerlo. Algunas son eficientes pero difíciles de entender, otras son sencillas pero lentas, otras son intermedias entre ambas.

Uno de los algoritmos de ordenación más simples y conocidos es el de "burbuja", en el que se va comparando cada dato con todos los anteriores, de modo que el más pequeño (el más "ligero", como si se tratara de una burbuja) vaya desplazándose hacia el final del array (como si "subiera hacia la superficie"). Tras cada pasada, el número más pequeño quedará colocado en su sitio:

(* ARRAYORD.PAS, Ordenar un array (burbuja) *)
(* Curso de Pascal, por Nacho Cabanes       *)

Program ArrayOrd;

var
    datos: array[1..6] of integer;
    i,j: integer;
    temporal: integer;

begin
    datos[1] := 20;
    datos[2] := 12;
    datos[3] := 7;
    datos[4] := 35;
    datos[5] := 49;
    datos[6] := 8;

    { Primero mostramos los datos }
    writeLn('Los datos iniciales son: ');
    for i := 1 to 6 do
        write(datos[i], ' ');
    writeLn;

    { Ahora ordenamos mediante burbuja }
    for i := 6 downto 2 do
        for j := 0 to i - 1 do
            if datos[j] > datos[j + 1] then
            begin
                temporal := datos[j];
                datos[j] := datos[j + 1];
                datos[j + 1] := temporal;
            end;

    { Y mostramos el resultado }
    writeLn('Los datos tras ordenar son: ');
    for i := 1 to 6 do
        write(datos[i], ' ');
    writeLn;
end.

(* Resultado:
Los datos iniciales son:
20 12 7 35 49 8
Los datos tras ordenar son:
7 8 12 20 35 49
*)