ARREGLOS DE UNA DIMENSIÓN

Los ejercicios de programación deben resolverse utilizando funciones que

modularicen las soluciones.

1. Suponga las siguientes declaraciones:

int puntos [500];

int prueba, menor, índice;

¿Cuál segmento de programa encontrará el valor más pequeño de este arreglo y

almacenará el subíndice del elemento donde está guardado este valor?

a) for (prueba = 0; prueba < 500; prueba++)

if (puntos[prueba] < menor)

menor = puntos[menor];

b) for (prueba = 0; prueba < 500; prueba++)

if (puntos[prueba] < menor)

menor = prueba;

c) menor = puntos[0];

for (prueba = 1; prueba < 500; prueba++)

if (puntos[prueba] < menor)

menor = puntos[prueba];

d) índice = 0;

for (prueba = 1; prueba < 500; prueba++)

if (puntos[prueba] < puntos[índice])

índice = prueba;

e) índice = 0;

for (prueba = 1; prueba < 500; prueba++)

if (puntos[prueba] < índice)

índice = prueba;

ARREGLOS UNIDIMENSIONALES

Un arreglo unidimensional es un tipo de datos estructurado que está formado por

una colección 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 posición 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 declaración.

Ejemplo: sea el siguiente 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 posición 1 guarda 34, en el arreglo X en la posición 2 guarda 22, así hasta la

última posición del arreglo X posición 5 guarda 72.

X [1]

34

X [2]

22

X [3]

39

X [4]

63

X [5]

72

Declaración 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 declaración de variables palabra reservada VAR.

Type

Nombre arreglo= array[x..y]of tipo dato;

Ejemplos:

Salarios= array [1…x] 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 información en ellos, para

esto usamos estructuras repetitivas la mas recomendable por su facilidad es el for,

una vez cargada la información se puede hacer cualquier operación de cálculo y

por último mostramos la información de los arreglos usando de igual manera la

estructura repetitiva for.

Carga de un arreglo, la letra i es el índice o subíndice del arreglo e indica la

posición del arreglo:

for i:=1 to num do

begin

readln(notas[i]);

end;

Mostrar la información de un arreglo, la letra i es el índice o subíndice del arreglo e

indica la posición del arreglo::

for i:=1 to num do

begin

writeln(notas[i]:3:1);

end;

Se han hechos programas que suman una cantidad de números usando dos

variables, una para leer cada número 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 números con una cantidad mínima de

código 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 número: ');

ReadLn(nums[i]);

s := s + nums[i];

End;

WriteLn('La suma es: ', s);

End.

Nótar el uso de una constante para marcar el tamaño del arreglo; dicha constante,

también sirve para controlar el For. De este modo, sólo se hace necesario cambiar

un número 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

números, luego dividirlos entre 3 y mostrarlos por pantalla *)

PROGRAM números;

USES CRT;

type

arreglo números=array[1..11]of real;

VAR

núm: arreglo números;

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 división son:' ,numero:2:2);

readln;

end;

end.

ARREGLOS BIDIMENSIONALES

Este tipo de arreglos al igual que los anteriores es un tipo de dato estructurado,

finito ordenado y homogéneo. El acceso a ellos también es en forma directa por

medio de un par de índices.

Los arreglos bidimensionales se usan para representar datos que pueden verse

como una tabla con filas y columnas. La primera dimensión del arreglo representa

las columnas, cada elemento contiene un valor y cada dimensión representa una

relación

La representación en memoria se realiza de dos formas: almacenamiento por

columnas o por renglones.

Para determinar el número total de elementos en un arreglo bidimensional

usaremos las siguientes fórmulas:

RANGO DE RENGLONES (R1) = Ls1 - (Li1+1)

RANGO DE COLUMNAS (R2) = Ls2 - (Li2+1)

No. TOTAL DE COMPONENTES = R1 * R2

REPRESENTACION EN MEMORIA POR COLUMNAS

x : array [1..5,1..7] of integer

Para calcular la dirección de memoria de un elemento se usan la siguiente

fórmula:

A[i,j] = base (A) + [((j - li2) R1 + (i + li1))*w]

REPRESENTACION EN MEMORIA POR RENGLONES

x : array [1..5,1..7] of integer

Para calcular la dirección de memoria de un elemento se usan la siguiente

fórmula:

A[i,j] = base (A) + [((i - li1) R2 + (j + li2))*w]

donde:

i = Indice del renglón a calcular

j = Indice de la columna a calcular

li1 = Límite inferior de renglones

li2 = Límite inferior de columnas

w = Número de bytes tipo componente

ARREGLOS MULTIDIMENSIONALES

Este también es un tipo de dato estructurado, que está compuesto por n

dimensiones. Para hacer referencia a cada componente del arreglo es necesario

utilizar n índice, uno para cada dimensión

Para determinar el número de elementos en este tipo de arreglos se usan las

siguientes fórmulas:

RANGO (Ri) = lsi - (lii + 1)

No. TOTAL DE ELEMENTOS = R1 * R2* R3 * ...* Rn

donde:

i = 1 ... n

n = No. total de dimensiones

Para determinar la dirección de memoria se usa la siguiente fórmula:

LOC A[i1,i2,i3,...,in] = base(A) + [(i1-li1)*R3*R4*Rn + (i2-li2)*R3*R2*... (in -

lin)*Rn]*w

Operaciones Con Arreglos

Las operaciones en arreglos pueden clasificarse de la siguiente forma:

Lectura

Escritura

Asignación

Actualización

Ordenación

Búsqueda

a) LECTURA

Este proceso consiste en leer un dato de un arreglo y asignar un valor a cada uno

de sus componentes.

La lectura se realiza de la siguiente manera:

para i desde 1 hasta N haz

x<--arreglo[i]

b) ESCRITURA

Consiste en asignarle un valor a cada elemento del arreglo.

La escritura se realiza de la siguiente manera:

para i desde 1 hasta N haz

arreglo[i]<--x

c) ASIGNACION

No es posible asignar directamente un valor a todo el arreglo, por lo que se realiza

de la manera siguiente:

para i desde 1 hasta N haz

arreglo[i]<--algún_valor

d) ACTUALIZACION

Dentro de esta operación se encuentran las operaciones de eliminar, insertar y

modificar datos. Para realizar este tipo de operaciones se debe tomar en cuenta si

el arreglo está o no ordenado.

Para arreglos ordenados los algoritmos de inserción, borrado y modificación son

los siguientes:

1.- Insertar.

Si i< mensaje(arreglo contrario caso En arreglo[i]<--valor i<--i+1 entonces>

2.- Borrar.

Si N>=1 entonces

inicio

i<--1

encontrado<--falso

mientras i<=n y encontrado=falso

inicio

si arreglo[i]=valor_a_borrar entonces

inicio

encontrado<--verdadero

N<--N-1

para k desde i hasta N haz

arreglo[k]<--arreglo[k-1]

fin

en caso contrario

i<--i+1

fin

fin

Si encontrado=falso entonces

mensaje (valor no encontrado)

3.- Modificar.

Si N>=1 entonces

inicio

i<--1

encontrado<--falso

mientras i<=N y encontrado=false haz

inicio

Si arreglo[i]=valor entonces

arreglo[i]<--valor_nuevo

encontrado<--verdadero

En caso contrario

i<--i+1

fin

fin

INTRODUCCION

Las computadoras fueron diseñadas o ideadas como una herramienta

mediante la cual podemos realizar operaciones de cálculo complicadas en un

lapso de mínimo tiempo. Pero la mayoría de las aplicaciones de este fantástico

invento del hombre, son las de almacenamiento y acceso de grandes cantidades

de información.

La información que se procesa en la computadora es un conjunto de datos,

que pueden ser simples o estructurados. Los datos simples son aquellos que

ocupan sólo una localidad de memoria, mientras que los estructurados son un

conjunto de casillas de memoria a las cuales hacemos referencia mediante un

identificador único.

Debido a que por lo general tenemos que tratar con conjuntos de datos y no

con datos simples (enteros, reales, booleanos, etc.) que por sí solos no nos dicen

nada, ni nos sirven de mucho, es necesario tratar con estructuras de datos

adecuadas a cada necesidad.

Las estructuras de datos son una colección de datos cuya organización se

caracteriza por las funciones de acceso que se usan para almacenar y acceder a

elementos individuales de datos.

CONCLUSIÓN

Se puede decir que los arreglos pueden variar dependiendo sus

dimensiones. Con respecto a los archivos no se requieren de un tamaño

predeterminado; esto significa que se pueden hacer archivos de datos más

grandes o pequeños, según se necesiten. Las aplicaciones pueden ser infinitas, ya

que son utilizados en diferentes rutinas diarias, como por ejemplo, acceder a

nuestro expediente en la universidad, para consultar el estado de cuenta bancario,

etc. La elección del método de ordenamiento está directamente relacionada con la

estructura de los registros del archivo y del soporte utilizado. Un programa puede

acceder directamente cualquier registro sin tener que leer los registros previos.

REPÚBLICA BOLIVARIANA DE VENEZUELA

UNIVERSIDAD NACIONAL EXPERIMENTAL

FRANCISCO DE MIRANDA

ÁREA DE TECNOLOGÍA

Br. Gabriela Hidalgo

C.I Nº 20.932.124

Ingeniería Química

Santa Ana de Coro, 18 de Enero 2011