CONCEPTO DE ARREGLO

Un array (se suele traducir como arreglo) es una estructura de datos

en la que se almacena una coleccin de datos del mismo tipo, por
ejemplo, las notas de un alumno, los salarios de los empleados de una
empresa.
Un array es una lista de un nmero determinado de elementos del
mismo tipo.

Caractersticas:
Almacenar los elementos del array en posiciones de memoria
continua.
Tener un nico nombre de variable (por ejemplo salarios) que
represente a todos los elementos. stos a su vez se diferencian por un
ndice o subndice.
Se puede accesar directa o aleatoriamente los elementos del array.

ARREGLOS UNIDIMENSIONALES
Un arreglo unidimensional es un tipo de datos estructurado que est
formado por una coleccin finita y ordenada de datos del mismo tipo.
Es la estructura natural para modelar listas de elementos iguales. Los
datos que se guarden en los arreglos todos deben ser del mismo tipo.

El tipo de acceso a los arreglos unidimensionales es el acceso directo,
es decir, podemos acceder a cualquier elemento del arreglo sin tener
que consultar a elementos anteriores o posteriores, esto mediante el
uso de un ndice para cada elemento del arreglo que nos da su
posicin relativa.
Para implementar arreglos unidimensionales se debe reservar espacio
en memoria.
Los arreglos nos permiten hacer un conjunto de operaciones para
manipular los datos guardados en ellos, estas operaciones son:
ordenar, buscar, insertar, eliminar, modificar entre otras.


REPRESENTACION EN MEMORIA: Los arreglos guardan en
memoria la cantidad de espacios que se le indican en la declaracin.

Ejemplo: sea el siguente arreglo unidimensional donde se va a guardar
5 datos de tipo entero (integer)

x : array[1..5] of integer
En memoria el computador guarda 5 espacios: esto quiere decir en el
arreglo X en la posicin 1 guarda 34, en el arreglo X en la posicin 2
guarda 22, asi hasta la ltima posicin del arreglo X posicion 5 guarda
72.
X [1]
34
X [2]
22
X [3]
39
X [4]
63
X [5]
72
Declaracion de los arreglos unidimensionales: Se declara el tipo
del arreglo, con la palabra reservada TYPE, luego se declara la
variable de tipo arreglo, esto se hace en el bloque de declaracion de
variables palabra reservada VAR.
Type
nombre_arreglo= array[x..y]of tipo_dato;
Ejemplos:
salarios= array [1x] of real;
nombre_trabajador=array[1..x] of string;
Nota: El tipo de dato del arreglo puede ser: integer,real, boolean, string
etc.
Variables tipo array
Var
sueldo:salarios;
nombre:nombre_trabajador;
Una vez declarados los arreglos procedemos a cargar informacin en
ellos, para esto usamos estructuras repetitivas la mas recomendable
por su facilidad es el for, una vez cargada la informacin se puede
hacer cualquier operacin de calculo y por ltimo mostramos la
informacin de los arreglos usando de igual manera la estructura
repetitiva for.
carga de un arreglo, la letra i es el indice o subindice del arreglo e
indica la posicin del arreglo:
for i:=1 to num do
begin
readln(notas[i]);
end;
Mostrar la informacin de un arreglo, la letra i es el indice o subindice
del arreglo e indica la posicin del arreglo::
for i:=1 to num do
begin
writeln(notas[i]:3:1);
end;
Se han hechos programas que suman una cantidad de nmeros
usando dos variables, una para leer cada nmero y otra para acumular
la suma. Este enfoque tiene la desventaja de que se pierden los
valores de los sumandos. El uso de arreglos permite calcular la suma
de los nmeros con una cantidad mnima de cdigo y a la vez
conservar cada valor, como muestra el siguiente programa completo:

Program SumaN;
Uses
Crt;
Const
n = 5;
Var
nums: Array[1..n] Of Integer;
s, i: Integer;
Begin
For i:=1 To n Do
Begin
Write('Escriba el nmero: ');
ReadLn(nums[i]);
s := s + nums[i];
End;
WriteLn('La suma es: ', s);
End.

Ntese el uso de una constante para marcar el tamao del arreglo;
dicha constante, tambin sirve para controlar el For. De este modo,
slo se hace necesario cambiar un nmero para adecuar el programa
a la escala apropiada
Ejercicios de arreglos unidimensionales:


* Dadas n cantidad de notas, calcular e imprimir el promedio de
las notas y todas las notas que fueron mayor a la media
calculada.

PROGRAM calificaciones;
USES CRT;
type
listacalificaciones=array[1..n]of real;
VAR
notas:listacalificaciones;
media,suma:real;
num,i:integer;

BEGIN
WRITELN('INTRODUZCA la cantidad de notas a procesar');
READLN(NUM);
suma:=0;

for i:=1 to num do
begin
readln(notas[i]);
suma:=suma+notas[i];
end;
media:=suma/num;
writeln('la media es:' , media:2:2);
writeln('la lista de calificaciones mayores a la media es:');
for i:=1 to num do
begin
if notas[i]>media then
writeln(notas[i]:3:1);
readln;
end;
END.

(*Escribir un programa en pascal que rellene un array con 11
numeros, luego dividirlos entre 3 y mostralos por pantalla *)

PROGRAM numeros;
USES CRT;
type
arreglonumeros=array[1..11]of real;
VAR
num:arreglonumeros;
i:integer;
numero:real;

BEGIN
for i:=1 to 11 do
begin
WRITELN('Introduzca el numero ' , i, ' a dividir');
readln(num[i]);
numero:=num[i]/3;
write('los numero resultantes de la division son:' ,numero:2:2);
readln;
end;
end.

OTRA FUENTE DONDE CONSEGUI:
Un arreglo es un conjunto de datos o una
estructura de datos homogneos que se
encuentran ubicados en forma
consecutiva en la memoria RAM (sirve
para almacenar datos en forma
temporal).

Arreglos unidimensionales: Es un tipo
de datos estructurado que est formado
de una coleccin finita y ordenada de
datos del mismo tipo. Es la estructura
natural para modelar listas de elementos
iguales. Estn formados por un conjunto
de elementos de un mismo tipo de datos
que se almacenan bajo un mismo
nombre, y se diferencian por la posicin
que tiene cada elemento dentro del
arreglo de datos. Al declarar un arreglo,
se debe inicializar sus elementos antes
de utilizarlos. Para declarar un arreglo
tiene que indicar su tipo, un nombre
nico y la cantidad de elementos que va
a contener.
Arreglos multidimensionales: Es un
tipo de dato estructurado, que est
compuesto por dimensiones. Para hacer
referencia a cada componente del
arreglo es necesario utilizar n ndices,
uno para cada dimensin. El trmino
dimensin representa el nmero de
ndices utilizados para referirse a un
elemento particular en el arreglo. Los
arreglos de ms de una dimensin se
llaman arreglos multidimensionales.
Arreglos con mltiple subndices: Es
la representacin de tablas de valores,
consistiendo de informacin arreglada en
renglones y columnas. Para identificar un
elemento particular de la tabla,
deberemos de especificar dos
subndices; el primero identifica el
rengln del elemento y el segundo
identifica la columna del elemento. A los
arreglos que requieren dos subndices
para identificar un elemento en particular
se conocen como arreglo de doble
subndice. Note que los arreglos de
mltiples subndices pueden tener ms
de dos subndices. El estndar ANSI
indica que un sistema ANSI C debe
soportar por lo menos 12 subndices de
arreglo.
manejo de arreglos.-
Declaracin de un arreglo: Se le da un
nombre y se de fine su tamao y el tipo
de datos que va a contener (caracteres,
enteros, reales, etc.)
En C:
int arreglo[10]; /* un arreglo de 10
enteros */
float arreglo[10]; /* un arreglo de 1 0
reales */
char arreglo[10]; /* un arreglo de 10
caracteres */
Altas, Bajas y Cambios ,Alta en un
arreglo: Se verifica que haya espacio y
se inserta el elemento en la posicin
disponible. Si el arreglo tiene un orden
determinado hay que buscar la posicin
correcta primero, luego recorrer los
elementos para generar un espacio y
finalmente se inserta el dato.
Alta en un arreglo (secuencial)
/* dato es el elemento a dar de alta y pos
indica la posicin
disponible */

alta(int arr[], int dato, int *pos)
{
if(*pos == MAX) /* Verifica si esta lleno */
printf("Error: el arreglo esta lleno");
else
{
arr[*pos] = dato; /* Inserta el dato */
*pos++; /*
Incrementa la posicin */
}
}
4.2.2 Manejo de arreglos.-
Alta en un arreglo (ordenado) :

/* dato es el elemento a dar de alta y
cantidad indica el nmero de
datos existentes. Este procedimiento
inserta un dato en un arreglo de enteros
en orden ascendente */ EJEMPLO ;
alta_ordenada(int arr[], int dato, int
*cantidad)
{
int i, pos;

if(*cantidad == MAX) /* Verifica si esta
lleno */
printf("Error: el arreglo esta lleno");
else
{
if(*cantidad == 0) /* El arreglo esta vaco
*/
{
arr[0] = dato; /* Inserta el dato */
*cantidad++; /* Incrementa la cantidad */
}
else
{
pos = 0;
for(i=0; i= arr[i])
pos = ++;
if(pos == *cantidad) /* Es el ltimo */
arr[pos] = dato; /* Inserta el dato */
else
{ /* Recorre los datos para hacer espacio
para el nuevo*/
for(i=cantidad; i>=pos; i--)
arr[i] = arr[i-1];
arr[pos] = dato; /* Inserta el dato */
4.2.3.-Manejo de arreglos.-

Baja en un arreglo
Para eliminar un elemento de un arreglo
primero se verifica que no est vaco el
arreglo, luego se busca el dato, se
elimina y, de ser necesario, se recorren
los dems para cubrir el espacio que
qued.
baja(int arr[], int dato, int *cantidad)
{
int i, pos;
if(*cantidad == 0) /* Verifica si hay datos
*/
printf("Error: el arreglo esta vaco");
else
{
pos = -1; /* Recorre el arreglo buscando
dato */
for(i=0; i