Está en la página 1de 12

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 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

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 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:

for i:=1 to num do

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::

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ó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

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.

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.

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.
El formato para declarar un arreglo unidimensional es:

tipo nombre_arr [ tamaño ]

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:

listanum[2] = 15; /* Asigna 15 al 3er elemento del


arreglo listanum*/
num = listanum[2]; /* Asigna el contenido del 3er
elemento a la variable num */
El lenguaje C no realiza comprobación de contornos en los arreglos. En el caso de que sobrepase
el final durante una operación de asignación, entonces se asignarán valores a otra variable o a
un trozo del código, esto es, si se dimensiona un arreglo de tamaño N, se puede referenciar el
arreglo por encima de N sin provocar ningún mensaje de error en tiempo de compilación o
ejecución, incluso aunque probablemente se provoque el fallo del programa. Como programador
se es responsable de asegurar que todos los arreglos sean lo suficientemente grandes para
guardar lo que pondrá en ellos el programa.
C permite arreglos con más de una dimensión , el formato general es:
tipo nombre_arr [ tam1 ][ tam2 ] ... [ tamN];
Por ejemplo un arreglo de enteros bidimensionales se escribirá como:

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,

tabladenums[2][3] = 15; /* Asigna 15 al elemento de la 3ª


fila y la 4ª columna*/
num = tabladenums[25][16];
A continuación se muestra un ejemplo que asigna al primer elemento de un arreglo bidimensional
cero, al siguiente 1, y así sucesivamente.

main()
{
int t,i,num[3][4];

for(t=0; t<3; ++t)


for(i=0; i<4; ++i)
num[t][i]=(t*4)+i*1;

for(t=0; t<3; ++t)


{
for(i=0; i<4; ++i)
printf("num[%d][%d]=%d ", t,i,num[t][i]);
printf("\n");
}

}
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

Arreglos bidimensionales en C++


Un arreglo de una dimensión es usado para representar elementos
en una lista o secuencia de valores. En algunos casos la relación
entre elementos del arreglo no pueden representarse en forma de
lista. Un arreglo de 2 dimensiones es usado para representar
elementos en una tabla con columnas y filas, se puede acceder a
cualquier elemento dentro del arreglo indicando el indice de la
columna y la fila del arreglo.

La siguiente figura muestra un arreglo con 4 filas y 4 columnas. Las


filas se acceden integrando un rango desde 0 hasta el 3 y las
columnas con un rango del 0 al 3. Un arreglo bi-dimensional se
declara de la misma manera que un arreglo unidimensional,
exceptuando que su tamaño debe ser declarado.

const int NUMFIL=4; //numero de filas


1
2
const int NUMCOL=4; //numero de columnas
3
4
float caja[NUMFIL][NUMCOL] //arreglo creado con las constantes anteriores. [NUMFIL]=primera dimens
5
ion. [NUMCOL] =segunda dimension.

Este ejemplo declara caja como un arreglo de 2 dimensiones cuyos


elementos son variables del tipo float. Para acceder a un elemento
individual del arreglo debe de especificar 2 expresiones (una por cada
dimensión) ejemplo: caja[0][2] donde [0] es fila y [2] columna.

Ejemplos de declaración de arreglos


bidimensionales en C++
Necesitamos un arreglo que muestre el clima de cada día de año
indicando la semana y el día (un arreglo de 52*7=364)

1 int clima[52][7];

Nuestro arreglo clima consta de 52 filas y 7 columnas partiendo del 0


al 51 y el 0 al 6, cada espacio de este contiene un valor int. Nuestra
intención es que el arreglo guarde los datos de cada día del año. Si
usamos la expresión clima[2][6], nos dará el clima del día 7 de la
tercer semana..

Procesando arreglos bidimensionales en C++


para dos dimensiones
Procesar los datos de un arreglo de 2 dimensiones generalmente
significa acceder al arreglo en uno o 4 patrones: aleatorio, a través
de columna, a través de filas o a través del arreglo entero. Por
ejemplo un usuario ingresa las coordenadas de un mapa a través de
un indice en el arreglo nombre_calle para llegar a la dirección que
desea, este proceso es conocido como aleatorio.

Hay veces que necesitamos utilizar una operación en cada elemento


de una fila o columna en el arreglo. Suponiendo en el caso anterior
del clima que queremos sacar un promedio de la temperatura de una
semana debemos sumar lo valores en la fila semana y dividirlo entre
7, este caso accede al arreglo a través de las filas, si por el contrario
lo que queremos es el promedio de un día de la semana en especifico
(ejemplo promedio de todos lunes del año) debemos sumar los
elementos de la columna días y dividirlo entre 52, este caso accede al
arreglo a través de las columnas, un ejemplo mas, si queremos sacar
el promedio del clima del año entero debemos acceder a cada
elemento del arreglo (en este caso el orden para acceder a las filas o
columnas no tiene relevancia) y dividirlo entre 364, esto accede a
todo el arreglo.
Considerando los 4 ejemplos comunes para procesar los arreglos
echemos un vistazo a los siguientes patrones para acceder a ellos.

1. sumar las filas.


2. sumar las columnas.
3. inicializar el arreglo en 0 (o algún valor especifico)
4. mostrar el arreglo.

Primero definimos algunas constantes y variables usando


identificadores generales como fila y columna.

1 const int NUMCOL=10;


2
3 const int NUMFIL=10;
4
5 int arreglo[NUMFIL][NUMCOL]; //arreglo bidimensional
6 int columna //indice de columna
7 int fila //indice de fila
8 int total //la variable para la suma

Sumando filas de arreglos bidimensionales en


C++
Suponiendo que queremos sumar la fila numero 3 (cuarta fila) en el
arreglo y queremos mostrarlo. Lo haremos fácilmente con la función
for

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;

el for de afuera controla las filas y el de adentro las columnas.

En la primera iteración se accede a la posición del arreglo:


arreglo[2][0], arreglo[2][1], arreglo[2[2] … arreglo[2][NUMCOL-1];

En la segunda accede a: arreglo[3][0], arreglo[3][1], arreglo[3][2]


…. arreglo[3][NUMCOL-1];

Si queremos acceder a una porción del arreglo declararemos las


siguientes variables (subarreglo)

1 int filaFilled //dato esta en 0.....filaFilled


2 int colFilled //datos esta en 0 ....colFilled

Entonces escribimos el fragmento de código siguiente

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;

Sumar columnas de arreglos bidimensionales


en C++
Supongamos que queremos sumar cada columna y mostrarlas.

Una vez mas generalizamos el código sumando solo la porción del


arreglo que contiene datos validos.

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.

Inicializando arreglos bidimensionales en C++


Como con los arreglos unidimensionales podemos inicializar los
arreglos bidimensionales en su declaración o usando declaración de
asignaciones.

Si el arreglo es corto es simple iniciarlo en su declaración, para iniciar


un arreglo de 2 flas y 3 columnas como este

14 4 -5
0 46 7

podemos usar la siguiente declaración

1 int arreglo[2][3]=
2{
3 {14, 3, -5},
4 {0, 46, 7}
5 };

En esta declaración la lista consiste en dos elementos, siendo cada


uno una lista de inicialización: la primera guarda los valores 14, 3, -5
en la fila 0 del arreglo; la segunda guarda los valores 0, 46 y 7 en la
fila 1.
Inicializar un arreglo en su declaración es impractico si el arreglo es
largo por ejemplo uno de 100*100, no necesariamente tienes que
listar 10,000 elementos. Si los valores son todos distintos deberías
guardarlos en un archivo y entrarlos en el arreglo al mismo tiempo
que corre el programa. Si los valores son iguales lo usual es anidar
iteraciones en su declaración de asignaciones, el siguiente ejemplo
inicializa todos los arreglos en 0.

1 for(fila=0;fila<NUMFIL;fila++)
2 for(columna=0;columna<NUMCOL;columna++)
3 arreglo[fila][columna]=0;

en este caso no importa si accedemos por las filas primero o las


columnas, mientras accedamos a todos los elementos del arreglo.

Mostrar arreglos bidimensionales en C++


Si queremos mostrar el arreglo con una fila por fila entonces
tendremos otro caso de procesamiento por fila:

1 #include <iomanip> //para el setw();


2 .
3 .
4 .
5 for(fila=0;fila<NUMFIL;fila++)
6 {
7 for(columna=0;columna<NUMCOL;columna++)
8 cout<<setw(15)<<arreglo[fila][columna];
9 cout<<endl;
10 }

Este fragmento de código imprime valores del arreglo en columnas de


15 caracteres.

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/