Você está na página 1de 6

Tipos de Arreglos

Arreglo unidimensional

Una arreglo uni-dimensional es aquel en donde los componentes son accedidos por
medio de uno y solamente un índice que apunte al componente requerido. Los arreglos
de este tipo son conocidos también con el nombre de vectores. Conceptualmente,
podemos pensar en un arreglo unidimensional como en una lista compuesta de líneas o
filas en donde para referinos a un elemento de ella emplearemos un número para indicar
la posición de dicho elemento dentro de la lista. Por ejemplo, consideremos el caso de la
tabla o arreglo VentaSemanal, la cual está pensada para registrar las ventas de cada uno
de los días de la semana. Luego, de manera conceptual podemos ver al arreglo como se
muestra en la figura.

arreglo: VentaSemanal

+------+
| dato | <-- componente 0, ( fila 0 )
|------|
| dato | <-- componente 1, ( fila 1 )
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | <-- componente 6, ( fila 6 )
|------|

Arreglo bidimensional

Un arreglo bidimensional es aquel en donde los componentes son accedidos por medio
de una pareja de índices que apunten a la fila y columna del componente requerido. Los
arreglos de este tipo son conocidos también con el nombre de matrices.
Conceptualmente, podemos pensar en un arreglo bidimensional como en una lista
compuesta de filas y columnas, en donde para referirnos a una de ellas emplearemos un
número para indicar la posición de fila y otro número para indicar la posición de la
columna del componente deseado. Por ejemplo, consideremos el caso de la tabla o
arreglo VentaSemanaQ, la cual está pensada para registrar las ventas de cada uno de los
días de la semana por cuatro semanas, o sea , una tabla de 7 x 4 elementos. Luego, de
manera conceptual podemos ver al arreglo como se muestra en seguida.
arreglo: VentaSemanaQ

C O L U M N A S

+--- componente ( 0, 0 )
|
+------+------+------+------+
| dato | dato | dato | dato |
|------|------|------|------|
F | dato | dato | dato | dato |
|------|------|------|------|
I | dato | dato | dato | dato |
|------|------|------|------|
L | dato | dato | dato | dato |
|------|------|------|------|
A | dato | dato | dato | dato |
|------|------|------|------|
S | dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
+------+------+------+------+
|
+---- componente ( 6, 3 )

Ejemplo1:

char matriz[X][Y]; à Bidimensional de tipo carácter. Podéis


observar su representación grafica a la derecha. Como podéis apreciar
en esta matriz, X adquiere el valor de 7 al igual que Y que también
vale 7. En este caso de matriz se requiere de dos índices para poder
acceder o guardar datos. Un ejemplo de almacenamiento de un
carácter en esta matriz seria: matriz[4][4]=10; Esto almacenaría el
valor 10 en la casilla que se encuentra en la posición X=4, Y=4. No me
digáis que nunca habéis jugado a hundir la flota de MB xD.

A continuación se muestra un ejemplo que asigna al primer elemento de un arreglo bidimensional cero, al
siguiente 1, y así sucesivamente.

int 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");
}
return 0;
}
Ejemplo2: En el siguiente programa se declara un arreglo en donde se almacenarán las
temperaturas de las 24 horas de los siete días de la semana. Las filas del arreglo
almacena los 7 días de la semana; las columnas del arreglo almacenan cada una de las
horas del día. Necesitamos dos ciclos para recorrer el arreglo bidimensional.

#include <stdio.h>
#define DIAS 7
#define HORAS 24

int main()
{
int temp[DIAS][HORAS];

float media = 0;
int hora, dia;

for( dia=0 ; dia<DIAS ; dia++ ) {


for( hora=0 ; hora<HORAS ; hora++ ) {
printf( "Temperatura de las %d el día %d: ", hora, dia );
scanf( "%i", &temp[dia][hora] );
media += temp[dia][hora];
}
}
media = media / HORAS / DIAS;

printf( "\nLa temperatura media de toda la semana es %f\n", media );


return 0;
}

Basándonos en el principio de creación de los arreglos bidimensionales podemos crear


arreglos de tres, cuatro o más dimensiones.

Para inicializar los arreglos con valores desde el inicio se hace de la siguiente manera:

int temperaturas[3][5] = {
{ 15, 17, 20, 25, 10 },
{ 18, 20, 21, 23, 18 },
{ 12, 17, 23, 29, 16 } };

Quedando así:

tipo variable[ filas ][ columnas ] = {


{ columnas de la fila 1 },
{ columnas de la fila 2 },
... ,
{ columnas de la última fila },
};

No debemos olvidar el ';' al final.


Iteraciones dentro de un arreglo unidimensional (vector)

El termino Iterar se refiere al hecho de acceder ( con el fin de leer o escribir) sobre cada
uno de los componenes de un arreglo. Así, para poner un ejemplo reconsideremos el
caso de la tabla VentaSemanal (vista en una sección anterior), y que dicho se de paso es
un arreglo de 7 elementos de tipo double. Luego, vamos a mostrar como ejemplo un
programa completo en el cual se declara el arreglo mencioando con valores
inicializados, mismos que serán mostrados en pantalla y al final la suma de estos.
Observe que la variable i usada para iterar dentro del arreglo va desde 0 hasta FILAS - 1
( FILAS es el tamaño del arreglo ).

Nota: por motivos de simplificación el programa está escrito al estilo de C estándar. Sin
embargo puede ser compilado y ejecutado en un compilador de C++.

Ejemplo3:

#include <stdio.h>
#include <stdlib.h>

#define FILAS 7

int main()
{
float VentaSemanal[FILAS] = {
123.50, 234.60, 345.45, 321.40, 345.00, 456.65, 0.0 };

float total = 0;
int i;

puts("Ventas de la semana");
puts("-------------------");

for (i=0; i<FILAS; i++) {


total += ventas[i];
printf( "%8.2f\n", ventas[i] );
}

puts("--------");
printf("%8.2f\n", total );

system("pause");
return 0;
}

Esta es la salida del programa:


Ventas de la semana
-------------------
123.50
234.60
345.45
321.40
345.00
456.65
0.00
--------
1826.60
Iteraciones dentro de un arreglo (matriz)

Con el fin de leer o escribir sobre cada uno de los componentes de una matriz se deben
crear dos ciclos de iteración. Así, para poner un ejemplo reconsideremos el caso de la
tabla VentaSemanaQ (vista en una sección anterior), y que dicho se de paso es un
arreglo de 7 x 4 elementos de tipo double. Luego, vamos a mostrar como ejemplo un
programa completo en el cual se declara el arreglo mencionado con valores
inicializados, mismos que serán mostrados en pantalla y al final la suma de estos.
Observe que en este caso se utilizan dos variables, una para iterar sobre las filas y otra
para iterar sobre las columnas de la matriz.

Ejemplo4:

#include <stdio.h>
#include <stdlib.h>

#define FILAS 7
#define COLS 4

int main()
{
float VentaSemanaQ[FILAS][COLS] = {
123.50, 234.60, 345.45, 321.40,
345.00, 456.65, 123.50, 234.60,
345.45, 321.40, 345.00, 456.65,
123.50, 234.60, 345.45, 321.40,
345.00, 456.65, 123.50, 234.60,
345.45, 321.40, 345.00, 456.65,
0.0, 0.0, 0.0, 0.0 };

float totales[COLS] = { 0.0, 0.0, 0.0, 0.0 };


float grantotal = 0;

int f, c, t = 0 ; /* indices para filas, columnas y totales */

puts("Ventas de cuatro semanas");


puts("------------------------");

for (f=0; f<FILAS; f++) {


for (c=0; c<COLS; c++) {
totales[c] += ventas[f][c];
printf("%8.2f ", ventas[f][c] );
}
puts("");
}
puts("--------------------------------------");
for (t=0; t<COLS; t++) {
printf("%8.2f ", totales[t] );
grantotal += totales[t];
}

printf("\n\nGran total: %10.2f\n", grantotal);


system("pause");
return 0;
}
Salida del programa:

Ventas de cuatro semanas


------------------------
123.50 234.60 345.45 321.40
345.00 456.65 123.50 234.60
345.45 321.40 345.00 456.65
123.50 234.60 345.45 321.40
345.00 456.65 123.50 234.60
345.45 321.40 345.00 456.65
0.00 0.00 0.00 0.00
--------------------------------------
1627.90 2025.30 1627.90 2025.30

Gran total: 7306.40

Você também pode gostar