4. ARRAYS, CADENAS, REGISTROS Y CONJUNTOS.

4.1. Arrays
4.1.1. Arrays de una dimensión
Un array (que algunos autores traducen como "arreglo") es una estructura que se utiliza para guardar una
serie de elementos, todos los cuales son del mismo tipo (por ejemplo, 20 números reales).
A la hora de definir un array, deberemos indicar el índice inferior y superior (desde dónde y hasta dónde
queremos contar), separados por dos puntos (..), así como el tipo de datos de esos elementos individuales.
Por ejemplo, para guardar hasta 200 números enteros, usaríamos:

lista: array [1..200] of integer

Se suele emplear para definir vectores o matrices. Para mostrar en pantalla el segundo elemento de esa lista
de números (o de ese vector) se usaría

write( lista[2] );

Un ejemplo completo, que guarde varios datos en un array y luego muestre uno de ellos podría ser:

(* ARRAY00.PAS, Contacto con arrays *)

(* Datos en posiciones prefijadas *)
(* Parte de CUPAS5, por Nacho Cabanes *)

Program Array00;

var
datos: array[1..4] of integer;

begin
datos[1] := 20;
datos[2] := 12;
datos[3] := 7;
datos[4] := 35;

writeLn('El segundo dato es ',dato[2]);

end.

Es habitual recorrer todo un array usando un bucle "for", de modo que podamos pedir y mostrar los datos de
forma repetitiva. Por ejemplo, podríamos pedir al usuario 5 números y luego mostrarlos en orden inverso, así:

(* ARRAY01.PAS, Ejemplo de uso de arrays (01): *)

(* Pedir datos y mostrarlos al revés *)
(* Parte de CUPAS5, por Nacho Cabanes *)

Program Array01;

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

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

write('Los datos al reves son: ');

for i := 5 downto 1 do
write(datos[i], ' ');

writeLn;
end.

4.1.2. 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 *)

(* Parte de CUPAS5, 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.

4.1.3. 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 *)

(* Parte de CUPAS5, 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
*)

4.1.4. Arrays de dos o más dimensiones

Cuando se trata de una matriz de 2, 3 o más dimensiones, podemos indicar los rangos de valores aceptables,
separados por comas. Por ejemplo, una matriz de bidimensional de tamaño 3x2 que debiera contener
números reales sería:
matriz1: array [1..3, 1..2] of real

y para ver el elemento (3,1) de la matriz haríamos:

writeLn( matriz1[3,1] );

Un ejemplo más completo, que pidiera 2x3 datos y mostrar uno de ellos sería:

(* ARRAYBI.PAS, Array bidimensional *)

(* Parte de CUPAS5, por Nacho Cabanes *)

program ArrayBi;

var
datos: array[1..2, 1..3] of integer;
fila,columna: integer;

begin
for fila := 1 to 2 do
for columna := 1 to 3 do
begin
write('Deme el dato de la fila ',fila,
' y columna ', columna, ': ');
readLn(datos[fila, columna]);
end;

writeLn('El dato de la fila 1 y columna 2 es ', datos[1,2]);

end.

(* Ejemplo de ejecucion:
Deme el dato de la fila 1 y columna 1: 1
Deme el dato de la fila 1 y columna 2: 20
Deme el dato de la fila 1 y columna 3: 3
Deme el dato de la fila 2 y columna 1: 54
Deme el dato de la fila 2 y columna 2: 15
Deme el dato de la fila 2 y columna 3: 9
El dato de la fila 1 y columna 2 es 20
*)

.
4.1.5. Sobredimensionar un array
Cuando no sabemos cuántos datos vamos a tener que guardar, una primera solución es sobredimensionar:
crear un array más grande de lo que esperemos necesitar y llevar un contador de cuántos datos ya hemos
almacenado:

(* ARRAYSD.PAS, Array sobredimensionado *)

(* Parte de CUPAS5, por Nacho Cabanes *)

program ArraySD;

var
datos: array[1..20] of integer; { Los datos en si }
cantidad: integer; { Cantidad de datos guardados }
i: integer; { Para bucles }

begin
{ Pedimos 200 datos o hasta introducir el valor 999 }
cantidad := 0;
repeat
if cantidad >= 200 then
writeLn('No caben mas datos!')
else
begin
cantidad := cantidad+1;
write('Deme el dato ',cantidad,' (999 para salir): ');
readLn(datos[cantidad]);
end;
until datos[cantidad]=999;

{ El ultimo dato no hay que guardarlo }

cantidad := cantidad-1;

{ Al final, muestro todos }

writeLn('Cantidad de datos: ', cantidad);
writeLn('Los datos al reves son: ');
for i := cantidad downto 1 do
write(datos[i], ' ');
writeLn;
end.

(* Ejemplo de ejecucion:
Deme el dato 1 (999 para salir): 23
Deme el dato 2 (999 para salir): 45
Deme el dato 3 (999 para salir): 7
Deme el dato 4 (999 para salir): 16
Deme el dato 5 (999 para salir): 999
Cantidad de datos: 4
Los datos al reves son: 16 7 45 23
*)

.
4.1.6. Borrar e insertar en un array
En un array sobredimensionado, nos puede interesar borrar o insertar datos. Para borrar, deberemos
desplazar hacia "la izquierda" (hacia el principio del array) los datos que hay desde esa posición, y luego
disminuir el contador de datos:

(* ARRAYBor.PAS, Borrar en un array sobredimensionado *)

(* Parte de CUPAS5, por Nacho Cabanes *)

Program ArrayBor;

var
datos: array[1..10] of integer;
cantidad: integer;
i: integer;
posicionBorrar: integer;

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

{ Primero mostramos los datos }

writeLn('Los datos iniciales son: ');
for i := 1 to cantidad do
write(datos[i], ' ');
writeLn;

{ Ahora borramos el tercero }

posicionBorrar := 3;
for i := posicionBorrar to cantidad-1 do
datos[i] := datos[i+1];
cantidad := cantidad-1;

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

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

De forma similar, podríamos insertar un dato en una cierta posición, si primero desplazamos hacia "la
derecha" (hacia el final del array) los datos que hay a partir de esa posición e incrementamos el contador que
almacena la cantidad de datos.

4.1.7. 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) *)

(* Parte de CUPAS5, 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
*)

ARREGLOS (array)

Un arreglo está formado por un número fijo de elementos contiguos de un mismo tipo.
Al tipo se le llama “tipo base” del arreglo. Los datos individuales se llaman “elementos”
del arreglo. Para definir un tipo estructurado arreglo, se debe especificar el tipo base y
el número de elementos.

Un array se caracteriza por:

1. Almacenar los elementos del array en posiciones de memoria continua,

2. Tener un único nombre de variable que representa a todos los elementos, y éstos a
su vez se diferencian por un índice o subíndice.
3. Acceso directo o aleatorio a los elementos individuales del array.

Los arrays se clasifican en:

• Unidimensionales (vectores o listas)

• Multidimensionales (tablas o matrices)

Las variables de tipo array se declaran en la sección Var o Type.

Declaración en Var
Var
nombres: array [1..30] of string;
calif: array [1..30] of real;
 numero: array [0..100] of 1..100;

Declaración en Type
Type
nombres= array [1..30] of string;
calif= array [1..30] of real;
numero= array [0..100] of 1..100;

Var
nom: nombres;
califica: calif;
num: numero;

Arreglos Unidimensionales

Un array de una dimensión (vector o lista) es un tipo de datos estructurado compuesto

de un número de elementos finitos, tamaño fijo y elementos homogéneos.

Supongamos que se desea conservar las edades de 10 personas. Para almacenar estas
edades se necesita reservar 10 posiciones de memoria, darle un nombre al array, y a
cada persona asignarle su edad correspondiente.

Nombre del vector: Edad

Subíndice: [ 1 ], [ 2 ],…
Contenido: Edad [ 2 ] = 15

Arreglos paralelos

Dos o más arrays que utilizan el mismo subíndice para referirse a términos homólogos
se llaman arrays paralelos.

Basados en el programa anterior, se tienen las edades de 'x' personas, para saber a qué
persona se refiere dicha edad se puede usar otro arreglo en forma paralela y asociarle
los nombres de manera simultánea con las edades.

Operaciones básicas

Lectura
Se dice que se efectúa una lectura, o acceso a la estructura, cuando una variable de tipo
arreglo figura como factor en una expresión. La evaluación del factor se logra,
previamente calculando el valor del índice, para luego acceder en la estructura el valor
de la componente correspondiente.

Escritura
Se dice que se efectúa una escritura, o asignación selectiva, si una variable de tipo
arreglo aparece a la izquierda en una instrucción de asignación. En este caso la expresión
de la derecha, debe tener igual tipo que la base del arreglo. También deben calcularse
la expresiones que figuran como índices de la variable, para asignarle posteriormente el
valor ya calculado de la expresión a la derecha del símbolo de asignación.