ARREGLOS MULTIDIMENSIONALES

(TRIDIMENCIONAL)

Este tambin es un tipo de dato estructurado, que est compuesto por n

dimensiones. Para hacer referencia a cada componente del arreglo es necesario
utilizar n ndices, uno para cada dimensin

Para determinar el nmero de elementos en este tipo de arreglos se usan las

siguientes frmulas:

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 direccin de memoria se usa la siguiente formula:

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

li2)*R3*R2*... (in - lin)*Rn]*w

ARREGLOS

El arreglo es un tipo estructurado de dato, el cual es capaz de almacenar una coleccin

de datos del mismo tipo.
Es la estructura de datos ms utilizada por los programadores
Es la forma ms simple de agrupar componentes de un mismo tipo y asociarles un
nmero de orden de cada componente llamado ndice.
Los arreglos en C, se almacenan en posiciones contiguas de memoria
Posee un tamao

CONCEPTOS BSICOS.
Los arreglos multidimensionales tienen ms de una dimensin. Las dimensiones
se manejan por medio de un par de corchetes, dentro de los que se escriben los
valores de cada dimensin, separados por comas.
EL ARREGLO TRIDIMENSIONAL

El arreglo tridimensional o de tres dimensiones, est formado por un conjunto de

elementos de un mismo tipo de datos que se almacenan bajo un mismo nombre
y que, al igual que en los unidimensionales y bidimensionales, se diferencian por
la posicin que tiene cada elemento dentro del arreglo de datos, con la aclaracin
de que la disposicin de los elementos es una combinacin del arreglo
unidimensional y bidimensional.

La primera dimensin se podra esquematizar como el arreglo unidimensional,

un conjunto de elementos; la segunda y tercera dimensin es un arreglo de dos
dimensiones que constituye a cada elemento de la primera dimensin
tridimensional de tipo entero. Como podemos observar lo que antes era una
msera lista se va convirtiendo en un cubo de impresionantes proporciones.
Ahora tenemos tres ndices con los que acceder a los datos X,Y,Z. La forma en
la accedemos y almacenamos datos en esta matriz puede parecernos un poco
abstracta, lo que hacemos es acceder a la interseccin de los tres ndices. Al ser
tridimensional tenemos que tomarnos los ndices como coordenadas que nos
dan un punto fijo, y es ese punto el que nuestra maquina va a reconocer como
el valor global.
 Un arreglo de tres dimensiones se podra leer como un arreglo de matrices, es decir, un arreglo
compuesto por X elementos , donde cada elemento es un arreglo de M x N de dos dimensiones
esquemticamente:

3 era dimensin
SEGUNDA DIMENSION
COLUMNAS

ELEMENTO 0 0 1 2 3 4

primera REGION 0
REGION 1
dimensin REGION 2
REGION 3
ELEMENTO 1
REGION 4
primera

dimensin

ELEMENTO 2

primera

dimensin

ELEMENTO 3

primera

dimensin

OPERACIONES:
Para manejar un arreglo, las operaciones a efectuarse son:

Declaracin del arreglo,

Creacin del arreglo,
Inicializacin de los elementos del arreglo, y
Acceso a los elementos del arreglo.

A continuacin, describiremos cada una de estas operaciones

A. DECLARACIN

La sintaxis para declarar un arreglo

multidimensional(TRIDIMENCIONAL) es la siguiente:

<tipo> [ , ...] < identificador > ;

Donde:
Tipo indica el tipo correspondiente a los elementos del arreglo,

Identificador es el nombre del arreglo, y

el par de corchetes, la coma y las diresis, [ , ...], representan las

dimensiones del arreglo. Los corchetes encierran todas las comas
necesarias para separar las dimensiones del arreglo.

Ejemplos:

int [ , , ] tridim ; // Tres dimensiones.

Observe que, en la declaracin, el espacio entre los corchetes est

vaco. Esto se debe a que, durante dicha operacin, no se reserva
espacio en la memoria.

B. CREACIN.

La creacin de un arreglo multidimensional (TRIDIMENCIONAL)

consiste en reservar espacio en la memoria para todos sus elementos,
utilizando la siguiente sintaxis:

< identificador > = new <tipo> [ dim1, dim2 ... dimN ] ;

Donde:

new es el operador para gestionar espacio de memoria, en tiempo de

ejecucin,

dim1, dim2, dimN son valores enteros que representan las dimensiones
del arreglo.

El tamao del arreglo es el resultado de multiplicar los valores de las

dimensiones y representa el nmero de elementos del arreglo.

Ejemplos:

tridim = new int[ 2, 3, 4] ;

Las operaciones de declaracin y creacin anteriores se pueden

agrupar en una sola instruccin, como se muestra enseguida:

int [ , , ] tridim = new int[2, 3, 4] ;

C. INICIALIZACIN
Un arreglo es un objeto que, cuando es creado por el compilador, se le
asignan automticamente valores iniciales predeterminados a cada uno
de sus elementos, de acuerdo a los siguientes criterios:

Si el tipo del arreglo es numrico, a sus elementos

se les asigna el valor cero.
Si el tipo del arreglo es char, a sus elementos se les
asigna el valor '\u0000'.
Si el tipo del arreglo es bool, a sus elementos se les
asigna el valor false.
Si el tipo del arreglo es una clase, a sus elementos
se les asigna el valor null.

Cuando se requiere asignar valores iniciales diferentes de los

predeterminados, es posible agrupar las operaciones de declaracin,
creacin e inicializacin en una sola instruccin, por ejemplo:

int [ , , ] tridim={{{12, 59, 70, 45} , {20, 16, 29, 48} , {93, 75, 43, 10}},

{{44, 72, 30, 24} , {60, 89, 39, 61} , {99, 52, 34, 47}}};

D. ACCESO

Se puede acceder a los valores de los elementos de un arreglo

bidimensional(tridimensional) a travs del nombre del arreglo y dos
subndices. Los subndices deben escribirse entre corchetes y
representa la posicin del elemento en el arreglo. As, podemos
referirnos a un elemento del arreglo escribiendo el nombre del arreglo y
los subndices del elemento entre corchetes. Los valores de los
subndices empiezan en cero para el primer elemento, hasta el tamao
del arreglo menos uno.

E. APLICACIONES.

Se necesita manejar, en un arreglo, la posicin todos los caracteres

escritos en una enciclopedia. El arreglo deber tener las siguientes
dimensiones:

Una para manejar el rengln en la pgina,

otra para la columna en la pgina,
otra para la hoja en el volumen y
otra para el volumen en la enciclopedia.
Cada pgina tiene 80 columnas.
Cada volumen tiene 500 pginas.
La enciclopedia tiene 18 volmenes.

El siguiente fragmento de programa implementa la solucin a este

problema.

char car;

// Declara y crea el arreglo.

char[ , , , ] enciclopedia = new char [18,500,80] ;

// Lee, desde el teclado, cada carcter para la enciclopedia.

for(int v = 0 ; v < 18 ; v++) // Volumen

for(int p = 0 ; p < 500 ; p++) // Pgina

for(int c = 0 ; c < 80 ; c++) // Columna

car = (char)[Link]( ) ;
enciclopedia[v,p,c] = car ;

DEFINICIN DEL ARREGLO TRIDIMENSIONAL

Como ya lo hemos mencionado al definir un arreglo es necesario hacerlo como una variable
por lo cual en la parte de declaracin de variables se utiliza el siguiente formato:

NomVar: Arreglo [primeraDim][segundaDim][terceraDim] TIPO DE DATO

En donde:

NomVar: es el nombre de la variable.

Arreglo: indica que es un arreglo

PrimeraDim: indica la cantidad de elementos de la primera dimensin.

SegundaDim: indica la cantidad de elementos de la segunda dimensin del arreglo.

TerceraDim: indica la cantidad de elementos de la tercera dimensin del arreglo.

Tipo de dato: es el tipo de dato de los elementos del arreglo.

Ejemplo
Nmeros: Arreglo [4][5][5] ENTERO

Nmeros Es un arreglo de tres dimensiones: de 4 elementos de 5x5, es decir,

un arreglo de 4 elementos, cada uno de los cuales es una matriz de 5x5.

MANEJO DE LOS ELEMENTOS DEL ARREGLO TRIDIMENSIONAL

Para relacionar cada elemento individual de un arreglo de tres dimensiones se usan tres
subndices; el primero indica la primera dimensin del elemento, el segundo la segunda
dimensin y el tercero la tercera dimensin, como sigue:

NomVar[primera][segunda][tercera]

En donde

Primera: indica el nmero de elemento en la primera dimensin

Segunda: indica el nmero de elemento en la segunda dimensin

Tercera: indica el nmero de elemento de la tercera dimensin.

NOTA los subndices pueden ser constantes, variables o expresiones de tipo entero.

Al igual que toda la variable, una de tipo arreglo tridimensional puede usarse para leer datos,
asignarle valores mediante expresiones aritmticas, imprimir su contenido etc.

EJEMPLOS

NomVar [2][3][4]= 50

Leer nomVar [2][2][3]

Leer nomVar [1][1][3]

NomVar [1][1][4]= NomVar [2][2][3] +NomVar [1][1][3] +NomVar [2][3][4]

Imprimir NomVar [1][1][4]

Ejemplo matriz 3D:

Supongamos que queremos guardar un dato en la posicin [x=2][y=5][z=3]; la
representacin grfica de donde se guardara este dato seria la imagen de la que
se observa ms abajo, como podemos ver se almacena en la interseccin entre
los tres puntos que en este caso esta dibujado como un tringulo. El valor que le
vamos a asignar es 10, por lo tanto, es tan sencillo como escribir en nuestro
compilador: MATRIZ [2][5][3]=10.
PROGRAMAS DE LENGUAJE JAVA

EJEMPLO
ELABORAR UN ALGORITMO QUE LEA [Link] DE TIPO ENTERO PARA UN ARREGLO
COMO EL ESQUEMATIZADO LNEAS ANTES, ES DECIR, UN ARREGLO DE 4X5X5 , Y LOS IMPRIMA.

Algoritmo ARREGLO TRIDIMENCIONAL

Clase ArregloTresDim1

1. Mtodo principal ()
a. Declarar variables
Nmeros: Arreglo [4][5][5] :entero
Prim,segu,terc:entero
b. For prim=0;prim<=3;prim++
1. For segu=0;segu<4;segu++
a. For terc=0;terc<=4;terc++
1. Solicitar elemento prim,segu,terc
2. Leer nmeros [prim][segu][terc]
b. Endfor
2. endfor
c. Endfor
d. For prim=0;prim<=3; prim ++
1. For segu=0; segu<4; seg++
a. For terc=0; terc<=4 ; terc ++
1. Imprimir nmeros [prim][segu][terc]
b. Endfor
2. Endfor
 e. Endfor
f. Fin mtodo principal

Fin clase ArregloTresDim1

Fin

PROGRAMA EN JAVA
import [Link];
public class ArregloTresDim1
{
public static void main(String args[])
{
// Declara // Variables
int numeros[][][] = new int[4][5][5];
int pri, seg, ter;

// Crear objeto para entrada de datos por el teclado

Scanner entrada = new Scanner([Link]);
// Leer datos
[Link]("-------- Lectura de datos --------");
for (pri = 0; pri <= 3; pri++)
{
for (seg = 0; seg <= 4; seg++)
{
for (ter = 0; ter <= 4; ter++)
{
[Link]("Teclee a[" + pri + "," + seg + "," + ter + "]: ");
numeros[pri][seg][ter] = [Link]();
}
}
}
// Imprimir salida
[Link]("------------ Salida ------------");
for (pri = 0; pri <= 3; pri++)
{
[Link]("----------- Matriz " + pri + " -----------");
for (seg = 0; seg <= 4; seg++)
{
for (ter = 0; ter <= 4; ter++)
{
[Link](numeros[pri][seg][ter] + " ");
}
[Link]();
}
}
}
}
LENGUAJE JAVA (SUMA DE MATRICES)
package trabajo3d;
import [Link];
public class array3 {

public static void main(String[] args) {

int i,j,k,m,n,p;
Scanner teclado = new Scanner([Link]);
//entrada
[Link]("Ingrese el valor de m: ");
m=[Link]();
[Link]("Ingrese el valor de n: ");
n=[Link]();
[Link]("Ingrese el valor de p:");
p=[Link]();
float A[][][]=new float [m][n][p];
float B[][][]=new float [m][n][p];
float S[][][]=new float [m][n][p];
//procesos
for(i=0;i<m;i++)
{for(j=0;j<n;j++)
{for(k=0;k<p;k++)
{[Link]("A["+(i+1)+"]["+(j+1)+"]["+(k+1)+"]:");
A[i][j][k]=[Link]();} }}

[Link]("");

for(i=0;i<m;i++)
{for(j=0;j<n;j++)
{for(k=0;k<p;k++)
{[Link]("B["+(i+1)+"]["+(j+1)+"]["+(k+1)+"]:");
B[i][j][k]=[Link]();}}}

[Link]("");
[Link]("La suma de los dos arreglos es la siguiente:");
//suma
for(i=0;i<m;i++)
{for(j=0;j<n;j++)
{for(k=0;k<p;k++)
{S[i][j][k]=A[i][j][k]+B[i][j][k];
[Link]("S["+(i+1)+"]["+(j+1)+"]["+(k+1)+"]:"+S[i][j][k]);}}}
}}
TERCER EJERCICIO
PRODUCCION DE PLANTAS
import [Link];
public class arreglo {
public static void main(String args[])
{
// Declarar
// Variables
int prod[][][] = new int[6][4][5];
int pla, est, dia, totEst, totDia, totPlanta, totProd,
mayPla, mayProdPla, mayEst=0, mayProdEst=0;

// Crear objeto para entrada de datos por el teclado

Scanner entrada = new Scanner([Link]);

[Link]("\nLEE LA PRODUCCION EN UN ARREGLO DE TRES DIMENSIONES");

[Link]("E IMPRIME EL REPORTE DE PRODUCCION EN LA PANTALLA");
[Link]("PRODUCCION[PLANTA][ESTACION][DIA]");

// Leer datos
[Link]("-------- Lectura de datos --------");
for (pla = 0; pla <= 2; pla++)
{
for (est = 0; est <= 1; est++)
{
[Link](" Planta " + (pla+1) + " ");
[Link]("Estacion " + (est+1));
for (dia = 0; dia <= 2; dia++)
{
[Link]("Produccion dia " + (dia+1) + ": ");
prod[pla][est][dia] = [Link]();
}
}
}

// Imprimir salida
[Link]("\n REPORTE SEMANAL DE PRODUCCION");
totProd = 0;
mayProdPla = 0;
for (pla = 0; pla <= 2; pla++)
{
[Link]("\n------------------- Planta " + (pla+1) + " ------------------");
[Link](" Dia 1 Dia 2 Dia 3 Dia 4 TOTAL");
[Link](" ----- ----- ----- ----- ----- -----");
mayProdEst = 0;
for (est = 0; est <= 1; est++)
{
[Link]("Estacion-" + (est+1) + " ");
totEst = 0;
for (dia = 0; dia <= 2; dia++)
{
[Link](prod[pla][est][dia] + " ");
totEst = totEst + prod[pla][est][dia];
}
[Link](totEst);
if (totEst > mayProdEst)
{
mayProdEst = totEst;
mayEst = est + 1;
 }
}
[Link](" ----- ----- ----- ----- ----- -----");
[Link](" Totales ");
totPlanta = 0;
for (dia = 0; dia <= 2; dia++)
{
totDia = 0;
for (est = 0; est <= 1; est++)
{
totDia = totDia + prod[pla][est][dia];
}
[Link](totDia + " ");
totPlanta = totPlanta + totDia;
}
[Link](totPlanta);
[Link](" Estacion mas productiva = " + mayEst);
[Link]("Produccion de estacion mas productiva = " + mayProdEst);
if (totPlanta > mayProdPla)
{
mayProdPla = totPlanta;
mayPla = pla + 1;
}
totProd = totProd + totPlanta;
}
[Link](" Total general de produccion = " + totProd);
[Link]("\n Planta mas productiva = " + mayEst);
[Link]("Produccion de planta mas productiva = " + mayProdEst);
}

}
LENGUAJE C++
EJERCICIO
/*un programa para registrar los tiempos de los chequeos de 4 velocistas que
compiten para un cupo en la clasificacin nacional. Cada velocista corre por un
carril, y se deben realizar 3 chequeos por cada velocista. Usted debe registrar
el nombre del velocista que corre por cada canal, registrar el tiempo de cada
prueba y su tiempo promedio. */

#include <iostream>
using namespace std;
int main()
{
char competidores [4][40]; /*Matriz de nombres de competidores*/
float carreras[4][3]; /*Matriz de tiempos en cada vuelta de los
competidores*/
float prom_competidores[4]; /*promedio de los competidores*/
 float acumulador=0;
cout << "Informacin del tiempo de cada competidor en el chequeo" << endl;
/*Llenando nombres de los participantes*/
for (int i=0;i<4;i++)
{
cout<<"Ingrese el nombre del competidor del carril "<<i+1<<endl;
gets(competidores [i]);
}
/*Llenando la matriz de tiempos en cada chequeo*/
for (int j=0;j<4;j++)
{
acumulador=0;
cout<<"Indique el tiempo del Competidor "<<competidores[j]<<endl;
for(int k=0;k<3;k++)
{
cout<<"En la prueba "<<k+1<<endl;
cin>>carreras[j][k];
acumulador=acumulador+carreras[j][k];
}
/*Guardando el promedio de las dos carreras en la matriz*/
prom_competidores[j]=acumulador/3;
}
/*Imprimiendo los resultados*/
for (int j=0;j<4;j++)
{
cout<<"El tiempo del Competidor "<<competidores[j];
for(int k=0;k<3;k++)
{
cout<<"\t"<<carreras[j][k];

}
cout<<"\tTiempo promedio= "<<prom_competidores[j]<<endl;
}
return 0;
}