Post on 29-Nov-2015
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