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 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 posición 1 guarda 34, en el arreglo X en la posición
2 guarda 22, asi hasta la última posición 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
Ejemplos:
nombre_trabajador=array[1..x] of string;
Nota: El tipo de dato del arreglo puede ser: integer,real, boolean, string etc.
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 calculo 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 indice o subindice del arreglo e indica la posición del arreglo:
begin
readln(notas[i]);
end;
Mostrar la información de un arreglo, la letra i es el indice o subindice del arreglo e indica la posición del arreglo::
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
s, i: Integer;
Begin
For i:=1 To n Do
Begin
ReadLn(nums[i]);
s := s + nums[i];
End;
End.
Nótese 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
* 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;
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.
Arreglos
Los arreglos (arrays) permiten almacenar vectores y matrices. Los arreglos unidimensionales
sirven para manejar vectores y los arreglos bidimensionales para matrices. Sin embargo, las
matrices tambien se pueden almacenar mediante arreglos unidimensionales y por medio de
apuntadores a apuntadores, temas que se veran en el capıtulo siguiente.
La palabra unidimensional no indica que se trata de vectores en espacios de dimensi´on uno;
indica que su manejo se hace mediante un sub´ındice. El manejo de los arreglos
bidimensionales se hace mediante dos subındices.
Los arreglos son una colección de variables del mismo tipo que se referencian utilizando un
nombre común. Un arreglo consta de posiciones de memoria contigua. La dirección más baja
corresponde al primer elemento y la más alta al último. Un arreglo puede tener una o varias
dimensiones. Para acceder a un elemento en particular de un arreglo se usa un índice.
Por ejemplo, para declarar un arreglo de enteros llamado listanum con diez elementos se hace
de la siguiente forma:
int listanum[10];
En C, todos los arreglos usan cero como índice para el primer elemento. Por tanto, el ejemplo
anterior declara un arreglo de enteros con diez elementos desde listanum[0] hasta listanum[9].
La forma como pueden ser accesados los elementos de un arreglo, es de la siguiente forma:
int tabladenums[50][50];
Observar que para declarar cada dimensión lleva sus propios paréntesis cuadrados.
Para acceder los elementos se procede de forma similar al ejemplo del arreglo unidimensional,
esto es,
main()
{
int t,i,num[3][4];
}
En C se permite la inicialización de arreglos, debiendo seguir el siguiente formato:
tipo nombre_arr[ tam1 ][ tam2 ] ... [ tamN] = {lista-valores};
Por ejemplo:
int i[10] = {1,2,3,4,5,6,7,8,9,10};
int num[3][4]={0,1,2,3,4,5,6,7,8,9,10,11}
http://introduccionprogramacionbuap.blogspot.com/2012/11/arreglos.html
Arreglos bidimensionales en
C++
Por
Hector
-
1 December, 2017
29232
2
6 min de lectura
1 int clima[52][7];
1 total=0;
2
3 for(columna=0;columna<NUMCOL;col++){
4 total=total+arreglo[3][columna];
5 }
6
7 cout<<"la suma es "<<total<<endl;
El for suma cada columna mientras mantienes fija la fila con el indice
3, sumando cada valor que hay en ella.
Ahora supongamos que queremos sumar la fila 2 y 3, anidamos un
for al que ya teníamos ejemplo:
1 total=0;
2
3 for(fila=2;fila<4;fila++){
4 for(columna=0;columna<NUMCOL;columna++){
5 total=total+arreglo[fila][columna];
6 }
7 }
8 cout<<"el total es "<<total<<endl;
1 total=0;
2
3 for(fila=2;fila<filaFilled;fila++){
4 for(columna=0;columna<columnaFilled;columna++){
5 total=total+arreglo[fila][columna];
6 }
7 }
8 cout<<"el total es "<<total<<endl;
1 total=0;
2
3 for(columna=0;columna<columnaFilled;columna++){
4 for(fila=2;fila<filaFilled;fila++){
5 total=total+arreglo[fila][columna];
6 }
7 }
8 cout<<"el total es "<<total<<endl;
En este caso el primer for controla las columnas y el interior las filas.
14 4 -5
0 46 7
1 int arreglo[2][3]=
2{
3 {14, 3, -5},
4 {0, 46, 7}
5 };
1 for(fila=0;fila<NUMFIL;fila++)
2 for(columna=0;columna<NUMCOL;columna++)
3 arreglo[fila][columna]=0;
No hay regla que diga que tenemos que imprimir cada fila en una
linea, podemos voltear el arreglo e imprimir cada columna en una
linea, simplemente cambiando los dos for.
Cuando imprimes un arreglo bidimensional, debes considerar cual
orden de presentación tiene mas sentido y como el arreglo encaja en
la pagina. Por ejemplo un arreglo de 6 columnas y 100 filas, seria
mejor presentado como 6 columnas y 100 lineas de largo.
https://blog.michelletorres.mx/arreglos-bidimensionales-en-c/