ARREGLOS EN TURBO PASCAL
Una estructura de datos es "una colección de datos organizados de un modo particular." Las estructuras de datos pueden ser de dos tipos: estáticas y dinámicas.
Las estructuras de datos estáticas son aquellas a las que se le asigna una cantidad fija de memoria cuando se declara la variable. Las estructuras de datos dinámicas son aquellas cuya ocupación de memoria puede aumentar o disminuir durante el tiempo de ejecución. Entre las estructuras de datos estáticas podemos encontrar los vectores y los arreglos, tema que estudiaremos a continuación.
En programación, una matriz o vector (llamados en inglés arrays) es una zona de almacenamiento contiguo, que contiene una serie de elementos del mismo tipo, los elementos de la matriz. Desde el punto de vista lógico una matriz se puede ver como un conjunto de elementos ordenados en fila (o filas y columnas si tuviera dos dimensiones). En principio, se puede considerar que todas las matrices son de una dimensión, la dimensión principal, pero los elementos de dicha fila pueden ser a su vez matrices (un proceso que puede ser recursivo), lo que nos permite hablar de la existencia de matrices multidimensionales, aunque las más fáciles de imaginar son los de una, dos y tres dimensiones.
Estas estructuras de datos son adecuadas para situaciones en las que el acceso a los datos se realice de forma aleatoria e impredecible. Por el contrario, si los elementos pueden estar ordenados y se va a utilizar acceso secuencial sería más adecuado utilizar una lista, ya que esta estructura puede cambiar de tamaño fácilmente durante la ejecución de un programa.
Índices
Todo vector se compone de un determinado número de elementos. Cada elemento es referenciado por la posición que ocupa dentro del vector. Dichas posiciones son llamadas índice y siempre son correlativos. Existen tres formas de indexar los elementos de una matriz:
• Indexación base-cero (0): En este modo el primer elemento del vector será la componente cero ('0') del mismo, es decir, tendrá el índice '0'. En consecuencia, si el vector tiene 'n' componentes la última tendrá como índice el valor 'n-1'. El C es un ejemplo típico de lenguaje que utiliza este modo de indexación.
• Indexación base-uno (1): En esta forma de indexación, el primer elemento de la matriz tiene el índice '1' y el último tiene el índice 'n' (para una matriz de 'n' componentes).
• Indexación base-n (n): Este es un modo versátil de indexación en la que el índice del primer elemento puede ser elegido libremente, en algunos lenguajes de programación se permite que los índices puedan ser negativos e incluso de cualquier tipo escalar (también cadenas de caracteres).
Vectores dinámicos y estáticos
Lo habitual es que un vector tenga una cantidad fija de memoria asignada, aunque dependiendo del tipo de vector y del lenguaje de programación un vector podría tener una cantidad variable de datos. En este caso, se les denomina vectores dinámicos, en oposición, a los vectores con una cantidad fija de memoria asignada se los denomina vectores estáticos.
El uso de vectores dinámicos requiere realizar una apropiada gestión de memoria dinámica. Un uso incorrecto de los vectores dinámicos, o mejor dicho, una mala gestión de la memoria dinámica, puede conducir a una fuga de memoria. Al utilizar vectores dinámicos siempre habrá que liberar la memoria utilizada cuando ésta ya no se vaya a seguir utilizando.
Lenguajes más modernos y de más alto nivel, cuentan con un mecanismo denominado recolector de basura (como es el caso de Java) que permiten que el programa decida si debe liberar el espacio basándose en si se va a utilizar en el futuro o no un determinado objeto.
Vectores multidimensionales
En Basic, Java y otros lenguajes es posible declarar matrices multidimensionales, entendiéndolas como un vector de vectores. En dichos casos en número de elementos del vector es el producto resultante de cada dimensión.
Por ejemplo el vector v (4,1) tiene 10 elementos se calcula del siguiente modo: (0-4) * (0-1). Los elementos de la primera dimensión del vector contiene 5 elementos que van del '0' al '4' y la 2º dimensión tiene 2 elementos que van desde '0' a '1'. Los elementos serían accedidos del siguiente modo:
elemento 1: (0,0)
elemento 2: (0,1)
elemento 3: (1,0)
...
elemento 8: (3,1)
elemento 9: (4,0)
elemento 10: (4,1)
Arrays unidimensionales: Los vectores
Un array de una dimensión (unidimensional), también llamado vector o fila, es un tipo de datos estructurado compuesto de un número determinado de elementos, de tamaño fijo y elementos homogéneos (del mismo tipo). La característica de tamaño fijo se refiere a que el tamaño del array debe ser conocido en tiempo de compilación.
Siempre se deben declarar luego de las constantes (si existen). Un array o vector se declara por medio del tipo de array. La sintaxis es la siguiente:
Type
Nombre_array = array [rango del subíndice] of tipo;
Nombre_array: Se refiere a un nombre de identificador válido.
Tipo_subíndice: Puede ser boolean, char o un rango de tipo enumerado.
Tipo: Se refiere al tipo de los elementos del vector. Todos los elementos deben ser del mismo tipo.
Ejemplos:
Type
X = array [1..8] of real;
Type
Luces = (Rojo, Verde, Ámbar);
Type
DiasDeSemana=(Lunes, Martes, Miércoles, Jueves, Viernes, Sábado, Domingo);
ConjuntoDias = array
Type
Salarios = array [A..Z] of real;
(En este caso es de tipo real porque el salario es de ese tipo. El subíndice indica que los salarios van de los empleados cuya inicial es A hasta la Z).
Las declaraciones de tipo array no crean ninguna variable específica de tipo array, sino que proporciona información del array como un todo.
Para declarar una variable tipo array, se utiliza la siguiente sintaxis:
Type
Valores = array [1..10] of real;
Var
Precios : Valores;
Primeramente se crea el tipo del array y luego se declara la o las variables referenciadas al array.
Otro ejemplo de aplicación puede ser el siguiente:
Const
Max = 500;
Type
Texto = array [1..Max] of char;
Var
Palabras, Letras: Texto;
En este ejemplo se crean dos variables arrays: Palabras y Letras. Las posiciones del array van de 1 a 500 y contendrán un valor tipo caracter.
Lectura y escritura de un vector
Lectura
Para leer un vector se debe hacer elemento a elemento y se requiere de alguna estructura repetitiva, ya sea un while, repeat o for.
Ejemplos:
I := 1; I := 1; For I:= 1 to n do
While I <= 100 do Repeat Readln(Notas[I]);
Begin Read (Notas[I]);
Read (Notas [I]); I := I + 1
I := I+1 Until I > 100
End;
Escritura
Para visualizar un vector, igualmente, es necesario situarlo dentro de una estructura repetitiva.
For I := 1 to Numero do
Writeln (Notas [I]:3);
Writeln; (* Evita que todas las salidas del vector aparezca en la misma línea *)
Arrays bidimensionales: Tablas o matrices
Un array bidimensional (también llamado tabla o matriz) es un array con dos índices. Al igual que los vectores deben ser ordinales. Se declaran de igual manera que los arrays de una dimensión.
Declaración de un array bidimensional
Al igual que en los arrays unidimensionales o vectores, se crean con declaraciones type y var y deben ser de tipo ordinales o subrango. Se deben indicar:
• El nombre del array
• Tipo del array
• Rango permitido
Ejemplo:
Type
Tabla = array [1..25,1..4] of real;
Var
Grados : Tabla;
Para localizar o almacenar un valor en el array se deben especificar dos posiciones o subíndices, uno para la fila y otro para la columna.
Escritura de una matriz
Para escribir un vector, se debe hacer referencia tanto a la fila como a la columna. Así:
For fila := 1 to 3 do
Begin
For Columna := 1 to 4 do
Write (A[Fila, Columna]:4);
End;
Ejemplo:
Calcular el promedio de cada estudiante de una lista de veinticinco alumnos de una clase de informática con notas en cuatro asignaturas.
Program Promedio;
Var
Notas : Array [1..25,1..4] of real;
I,J : Integer;
Suma,Prom: Real;
Begin
For I := 1 to 25 do
Begin
Write (`Notas del estudiante: ´,I:1);
Writeln (`En una misma línea digite todas las notas´);
Suma := 0;
For J := 1 to 4 do
Begin
Read (Notas[I,J]);
Suma := Suma + Notas[I,J]
End;
Readln;
Prom := Suma/4;
Writeln (`La nota promedio del estudiante `,I:1,´ es `,Prom:1:1)
End
End.
En Turbo Pascal un Array o arreglo es una variable que repite un tipo de datos un número limitado de veces, la sintaxis es la siguiente:
Nombre_arreglo=array[limite_inferior . . limite_superior]of tipo de datos
Donde :
Nombre_arreglo
Hace referencia al identificador del tipo de dato del que más adelante se sacarán las variables, este puede ser cualquiera, pero es aconsejable que este relacionado con la función que se va a desarrollar.
Array es la palabra reservada que le indica a Pascal que se va a definir un tipo Arreglo.
En los paréntesis cuadrados se indica la extensión del arreglo y la forma, que puede ser:
1. Vectores
El límite inferior empieza en 1 y el superior es un valor entero positivo, a continuación te muestro tres de las formas para declararlos:
Program forma1;
Uses crt;
Const
Maximo=10;
Type
Vector=array[1..Maximo] of integer;
Program forma2;
Uses crt;
Const
Maximo=10;
Type
Contenido=1..Maximo;
Vector=array[Contenido] of integer;
Program forma3;
Uses crt;
Const
Maximo=10;
Var
Vector:array[1..Maximo] of integer;
2. Matrices
Observando las gráficas puedes ya determinar la diferencia entre un vector y una matriz, esta última está compuesta por filas y columnas, para declararse el primer factor en los paréntesis cuadrados [] hace referencia a las filas, y el segundo a las columnas, ahora veamos varias formas de declarar una matriz.
Program forma1;
Uses crt;
Const
Maxima_fila=10;
Maxima_columna=10;
Type
Matriz=array[1..Maxima_fila,1..Maxima_columna] of integer;
Program forma2;
Uses crt;
Const
Maxima_fila=10;
Maxima_columna=10;
Type
Contenido=1..Maxima_fila,1..Maxima_columna;
Matriz=array[Contenido] of integer;
Program forma3;
Uses crt;
Const
Maxima_fila=10;
Maxima_columna=10;
Var
Matrizr:array[1..Maxima_fila,1..Maxima_columna] of integer;
