Arrays de Varias Dimensiones Primera Parte

Universidad Los Angeles de Chimbote Sistema de Educación Virtual
ARRAYS DE VARIAS DIMENSIONES
Los vectores examinados hasta ahora se denominan arrays unidimensionales y

en ellos cada elemento se define o referencia por un índice o subíndice. Estos
vectores son elementos de datos escritos en una secuencia. Sin embargo,
existen grupos de datos que son representados mejor en forma de tabla o matriz
con dos o más subíndices.
Ejemplos típicos de tablas o matrices son tablas de distancias kilométricas entre

ciudades, cuadros horarios de trenes o aviones, informes de ventas periódicas
(mes/unidades vendidas o bien mes/ ventas totales), etc. Se puede definir tablas
o matrices como arrays multidimensionales , cuyos elementos se pueden
referenciar por dos, tres o más subíndices. Los arrays no unidimensionales los
dividiremos en dos grandes grupos:
arrays bidimensionales (2 dimensiones)

arrays multidimensionales (3 o más dimensiones)
Una matriz mutidimensional, como su nombre lo indica es una matriz de dos o

más dimensiones. Algunos lenguajes de programación como Java no soportan
matrices multidimensionales; pero se puede lograr la misma funcionalidad
declarando matrices de matrices, las cuales a su vez pueden también contener
matrices, y así sucesivamente, hasta llegar a obtener el número de dimensiones
deseadas, como veremos en los ejemplos de este capítulo.
Matrices numéricas multidimensionales

La definición de una matriz numérica de varias dimensiones se hace de la forma
siguiente:
Tipo [][] ….. nombre_matriz = new tipo [exp.-1][exp.-2] ….. ;
Donde tipo es un tipo primitivo entero o real. El número de elementos de una

matriz multidimensional es el producto de las dimensiones indicadas por exp.-1,
exp.-2, ….. Por ejemplo, la línea de código siguiente crea una matriz de dos
dimensiones con 2x3=6 elementos de tipo int.
int [][] m = new int [2][3] ;
A partir de la línea de código anterior, java crea una matriz unidimensional m con
2 elementos m[0] y m[1] que son referencias a otras dos matrices
unidimensionales de 3 elementos. Gráficamente podemos imaginarlo así:
Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 1

Matriz m
mo m1
Fila 0
Fila 1
Evidentemente, el tipo de los elementos de la matriz referenciada por m es int[] y

el tipo de los elementos de las matrices referenciadas por m[0] y m[1] es int.
Además, puede comprobar la existencia y la longitud de las matrices
unidimensionales referenciadas por m, m[0] y m[1] utilizando el código siguiente:
int [][] m = new int [2][3] ;

System.out.println(m.length) // Resulado 2;
System.out.println(m[0].length); // Resulado 3
System.out.println(m[1].length); // Resulado 3
Arrays bidimensionales (tablas/matrices)

El array bidimensional se puede considerar como un vector de vectores. Como
hemos visto, es un conjunto de elementos, todos del mismo tipo, en el cual el
orden de los componentes es significativo y en el que se necesita especificar dos
subíndices para poder identificar cada elemento del array.
Si se visualiza un array unidimensional, se puede considerar como una columna

de datos; un array bidimensional es un grupo de columnas, como se ilustra en la
siguiente figura:
Fila 1
Fila 2
Fila 3
Fila 4
Fila 5
Col.1 Col.2 Col. 3 Col.4 Col. 5 Col. 6
Columnas

El diagrama representa una tabla o matriz de treinta elementos (5 x 6) con 5 filas

y 6 columnas. Como en un vector de treinta elementos, cada uno de ellos tiene el
mismo nombre. Sin embargo un subíndice no es suficiente para especificar un
elemento de un array bidimensional; por ejemplo, si el nombre del array es M, no
se puede indicar M[J], ya que no sabemos si es el tercer elemento de la primera
fila o la primera columna. Para evitar la ambigüedad, los elementos de un array
bidimensional se referencian con dos subíndices: el primer subíndice se refiere a
la fila y el sgundo subíndice se refiere a la columna, por consiguiente M[2,3] se
refiere al elemento de la segunda fila, tercera columna.
Un array bidimensional también denominado matriz (términos matemáticos) o

tabla (términos financieros) se considera que tiene dos dimensiones (una
dimensión por cada índice) y necesita un valor para cada subíndice para poder
identificar un elemento individual. En notación estándar, normalmente el primer
subíndice se refiere a la fila del array, mientras que el segundo subíndice se
refiere a la columna del array. Es decir B[I,J] es el elemento de B que ocupa la Ia
fila y la Ja columna .
Columnas 1 2 3 4 …. J …. N
Fila 1
Fila 2
…..
B[I,J]
Fila I
……
Fila M
El array B se dice que tiene M x N elementos. Existen N elementos en cada fila y

M elementos en cada columna (MxN).
Primer ejemplo:
Como ejemplo de aplicación de matrices bidimensionales, vamos a realizar un
programa que asigne datos a una matriz m de dos dimensiones y a continuación

escriba las sumas correspondientes a las filas de la matriz. La ejecución del

programa presentará el aspecto siguiente:
Número de filas de la matriz: 2

Número de columnas de la matriz: 2
Introducir los valores de la matriz:
m[0][0] =2
m[0][1] =5
m[1][0] =3
m[1][1] =6
Suma de la fila 0 : 7.0
Suma de la fila 1 : 9.0
Fin del proceso
En primer lugar definimos las variables que almacenarán el número de filas y

columnas de la matriz, y a continuación leemos esos valores del teclado,
desechando cualquier valor negativo.
int nfilas, ncols; // filas y columnas de la matriz

do
{
System.out.print("Número de filas de la matriz: ");
nfilas = Lector.nextInt();
}
while (nfilas < 1); //********* no permitir un valor negativo
do
{
System.out.print("Número de columnas de la matriz: ");
ncols = Lector.nextInt();
}
while (ncols < 1); //********* no permitir un valor negativo
Después, creamos la matriz m con el número de filas y columnas especificado,

definimos la variable fila y col que utilizaremos para manipular los subíndices
correspondientes a la fila y a la columna y la variable sumafila para almacenar la
suma de los elementos de una fila.
float[][] m = new float[nfilas][ncols]; //**** crear la matriz m

int fila = 0, col = 0; //******** subíndices
float sumafila = 0; //******* suma de los elementos de una fila
El paso siguiente es asignar un valor desde el teclado a cada elemento de la

matriz.
for (fila = 0; fila < nfilas; fila++)

{
for (col = 0; col < ncols; col++)
{
System.out.print("m[" + fila + "][" + col + "] = ");
m[fila][col] = Lector.nextFloat();
}
}
Una vez creada la matriz, calculamos la suma de cada fila y visualizamos los
resultados para comprobar el trabajo realizado.
System.out.println();
{
sumafila = 0;
sumafila += m[fila][col];
System.out.println("Suma de la fila " + fila + ": " + sumafila);
}
El programa completo se muestra a continuación:
//
//
//
import java.util.*;
public class CMatrizMultidimensional
{
//******* Creación de una matriz multidimensional.
//******* Suma de las filas de una matriz de dos dimensiones.
public static void main(String[] args)
{
int nfilas, ncols; // filas y columnas de la matriz
do
{
nfilas = Lector.nextInt();
}
while (nfilas < 1); //********* no permitir un valor negativo
do
{
System.out.print("Número de columnas de la matriz: ");
ncols = Lector.nextInt();
}
while (ncols < 1); //********* no permitir un valor negativo
float[][] m = new float[nfilas][ncols]; //**** crear la matriz m

int fila = 0, col = 0; //******** subíndices

float sumafila = 0; //******* suma de los elementos de una fila
System.out.println("Introducir los valores de la matriz.");

{
{
System.out.print("m[" + fila + "][" + col + "] = ");
m[fila][col] = Lector.nextFloat();
}
}
//******* Visualizar la suma de cada fila de la matriz

System.out.println();
{
sumafila = 0;
sumafila += m[fila][col];
System.out.println("Suma de la fila " + fila + ": " + sumafila);
}
System.out.println("\nFin del proceso.");
}
}
Matrices de cadenas de caracteres

Las matrices de cadenas de caracteres son matrices multidimensionales,
generalmente de dos dimensiones, en las que cada fila se corresponde con una
cadena de caracteres. Entonces, según lo estudiado, una fila puede ser un
objeto matriz unidimensional, un objeto String o un objeto StringBuffer.
Haciendo un estudio análogo al realizado paras las matrices numéricas

multidimensionales, la definición de una matriz de cadenas de caracteres puede
hacerse de la forma siguiente:
char [ ][ ] nombre_matriz = new char [filas][longitud_fila];
Por ejemplo, la siguiente línea de código crea una matriz de cadenas de

caracteres de F filas por C caracteres máximos por cada fila.
char [ ][ ] m = new char [F][C];
A partir de la línea de código anterior una matriz unidimensional m con los

elementos, m[0],m[1], … m[F-1], que son referencias a otras tantas matrices
unidimensionales de C elementos de tipo char.
Evidentemente, el tipo de los elementos de la matriz referenciada por m es char[]

y el tipo de los elementos de las matrices referenciadas por m[0], m[1], …es

char. Desde nuestro punto de vista es más fácil imaginarse una matriz de
cadenas de caracteres como una lista. Por ejemplo, la matriz m del ejemplo
anterior estará compuesta por las cadenas de caracteres m[0], m[1], …, etc.
mo
m1
m2
m3
Para acceder a los elementos de la matriz m, puesto que se trata de una matriz
de cadenas de caracteres, utilizaremos sólo el primer subíndice , el que indica la
fila. Sólo utilizaremos dos subíndices cuando sea necesario acceder a un
carácter individual.
Por ejemplo, la primera sentencia del ejemplo siguiente crea una matriz de
cadenas de caracteres. La segunda asigna una cadena de caracteres a m[0]
desde el teclado; la cadena tendrá nCarsPorFila caracteres como máximo y será
almacenada a partir de la posición 0 de m[0]. Y, la tercera sentencia, reemplaza
el último carácter leido en m[0] por “\0”, puesto que read devuelve el número de
caracteres leídos.
char[][] m = new char [nFilas][ nCarsPorFila] ;

nCarsLeidos = flujoE.read(m[0],0, nCarsPorFila);
m[0] [nCarsLeidos -1] =“\0” ;
Es importante hacer recordar que que m[0], m[1], … etc son cadenas de
caracteres y que, por ejemplo, m[1][3] es un carácter, el que está en la fila 1,
columna 3.
Pata ilustrar la forma de trabajar con cadenas de caracteres, vamos a realizar un

programa que lea una lista de nombres y los almacene en una matriz, Una vez
construida la matriz, visualizaremos su contenido.
La solución tendrá el siguiente aspecto:
Número de filas de la matriz: 10

Número de caracteres por fila: 40
Escriba los nombres que desea introducir.
Puede finalizar pulsando las teclas [Ctrl.][Z]
Nombre[0] = María
Nombre[1] = Francisco
Nombre[2] = Javier
Nombre[3] = [Ctrl.][Z]
Desea visualizar el contenido de la matriz (s/n) : S

María
Francisco
Javier
La solución pasa por realizar los siguientes pasos:

1. Definir una matriz de cadenas, los índices y demás variables necesarias.
2. Establecer un bucle para leer las cadenas de caracteres utilizando el
método read. La entrada de datos finalizará al introducir la marca de fin de
archivo.
3. Preguntar al usuario del programa si quiere visualizar el contenido de la
matriz.
4. Si la respuesta anterior es afirmativa, establecer un bucle para visualizar
las cadenas de caracteres almacenadas en la matriz.
//
//
import java.io.*;
import java.util.*;
public class CMatriz1Cadenas

{
{
try
{
//******** Definir un flujo de caracteres de entrada: flujoE
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader flujoE = new BufferedReader(isr);
//********* Definir una referencia al flujo estándar de salida: flujoS

PrintStream flujoS = System.out;
int nFilas = 0, nCarsPorFila = 0;

int fila = 0, nCarsLeidos = 0, eof = -1;
Scanner Lector = new Scanner(System.in);
do
{
nFilas = Lector.nextInt();
}
while (nFilas < 1); // no permitir un valor negativo
do
{
System.out.print("Número de caracteres por fila: ");
nCarsPorFila = Lector.nextInt();
}
while (nCarsPorFila < 1); // no permitir un valor negativo
//******** Matriz de cadenas de caracteres
char[][] nombre = new char[nFilas][nCarsPorFila];

System.out.println("Escriba los nombres que desea introducir.");

System.out.println("Para finalizar pulse las teclas [Ctrl][Z].");
for (fila = 0; fila < nFilas; fila++)
{
flujoS.print("Nombre[" + fila + "]: ");
nCarsLeidos = flujoE.read(nombre[fila], 0, nCarsPorFila);
//************* Si se pulsó [Ctrl][Z], salir del bucle
if (nCarsLeidos == eof) break;
//************* Eliminar los caracteres CR LF
nombre[fila][nCarsLeidos-1] = '\0';
nombre[fila][nCarsLeidos-2] = '\0';
}
flujoS.print("\n\n");
nFilas = fila; // número de filas leídas
char respuesta;
do
{
flujoS.print("¿Desea visualizar el contenido de la matriz? (s/n): ");
respuesta = ((flujoE.readLine()).toLowerCase()).charAt(0);
}
while (respuesta != 's' && respuesta != 'n');
if ( respuesta == 's' )
{
//*************** Visualizar la lista de nombres
flujoS.println();
flujoS.println(nombre[fila]);
}
}
catch (IOException ignorada) { }
}
}
El identificador nombre hace referencia a una matriz de caracteres de dos

dimensiones. Una fila de esa matriz es una cadena de caracteres (una matriz de
caracteres unidimensional) y la biblioteca de Java provee el método read para
leer matrices unidimensionales de caracteres. Por eso, para leer una fila (una
cadena de caracteres) utilizamos sólo un índice. Esto no es aplicable a las
matrices numéricas de dos dimensiones, ya que la biblioteca de Java no
proporciona métodos para leer filas completas, lo cual es lógico.
Siguiendo con el análisis del programa anterior, la entrada de datos finalizará

cuando se haya introducido la marca de fin de archivo, o bien cuando se hayan
introducido la totalidad de los nombres.
Asimismo, una vez finalizada la entrada de los datos, se lanza una pregunta
acerca de si se desea visualizar el contenido de la matriz. En este caso, la
respuesta tecleada, se obtiene con readLine. Como este método lee hasta el

carácter ‘\n’ inclusive, utilizamos el método charAt para obtener del String
devuelto por readLine el primer carácter, que deberá ser una ‘s’ o una ‘n’.
Observa la respuesta:
Es equivalente a:
String s=flujoE.readLine()
s = s.toLowerCase();
respuesta = s.charAt(0);
¿De qué longitud son las cadenas de caracteres nombre [0], nombre [1], etc.?
Independientemente del número de caracteres leídos para cada uno de los
nombres solicitados, todas son de la misma longitud.-. nCarsPorFila caracteres
(recuerda que las matrices de caracteres son iniciadas con nulo); para verificarlo
puede recurrir al atributo length de las matrices. Evidentemente, esta forma de
proceder supone un derroche de espacio de memoria, que se puede evitar
haciendo que cada fila de la matriz nombre tenga una longitud igual al número de
caracteres del nombre que almacena. Apliquemos esta teoría al programa
anterior.
El proceso que seguiremos para solucionar el problema planteado es el

siguiente:
• Definimos la matriz de referencia a las matrices unidimensionales que
serán las filas de una supuesta lista.
char[ ][ ] nombre = new char[nFilas];
No asignamos memoria para cada una de las cadenas porque no

conocemos su longitud (nombre[0] = null, nombre[1] = null, etc). Por lo
tanto, este proceso lo desarrollaremos posteriormente a la lectura de cada
una de ellas.
• Leemos las cadenas de caracteres. Para poder leer una cadena,

necesitamos definir una matriz de caracteres que vamos a denominar
unNombre. Esta será una matriz unidimensional de longitud 81 caracteres,
por ejemplo:
char[ ][ ] unNombre = new char[81];
• Una vez leída la cadena, conocemos cuántos caracteres se han leído,

entonces, reservamos memoria (new) para almacenar ese número de
caracteres, almacenamos la referencia de memoria reservado en el
siguiente elemento vacío de la matriz de referencia nombre y copiamos
Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán10

unNombre en el nuevo bloque asignado (fila de la matriz nombre). Este

proceso lo repetiremos para cada uno de los nombres que leamos.

{
nCarsLeidos = flujoE.read(unNombre, 0, nCarsPorFila);
// Si se pulsó [Ctrl][Z], salir del bucle
// Añadir el nombre leído a la matriz nombre
nombre[fila] = new char[nCarsLeidos-2]; // menos CR LF
for (int i = 0; i < nCarsLeidos-2; i++)
nombre[fila][i] = unNombre[i]; // copiar
}
Gráficamente puedes imaginarte el proceso descrito de acuerdo a la

siguiente estructura de datos:
unNombre J e s ú s \r \n
nombre
nombre0 C a r m e n Fila 0
nombre1 F r a n c I s c o Fila 1
nombre2 J e s ú s Fila 2
….
La sentencia nombre[fila] = new char[nCarsLeidos-2] asigna para cada valor

de fila un espacio de memoria de nCarsLeidos – 2 caracteres(en la figura
fila 0, fila 1, fila 2, etc.) para copiar la cadena leída a través de unNombre.
Recuerda que el método read devuelve el número de caracteres leídos.
• Una vez leída la matriz la visualizamos si la respuesta a la petición de

realizar este proceso es afirmativa.
//****
import java.io.*;
import java.util.*;
public class CMatriz2Cadenas

{
{
try
{

//****** Definir un flujo de caracteres de entrada: flujoE

InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader flujoE = new BufferedReader(isr);
//****** Definir una referencia al flujo estándar de salida: flujoS

PrintStream flujoS = System.out;
int nFilas = 0, nCarsPorFila = 81;

int fila = 0, nCarsLeidos = 0, eof = -1;
char[] unNombre = new char[nCarsPorFila];
do
{
nFilas = Lector.nextInt();
} while (nFilas < 1); // no permitir un valor negativo
//****** Matriz de cadenas de caracteres
char[][] nombre = new char[nFilas][];
System.out.println("Escriba los nombres que desea introducir.");

System.out.println("Puede finalizar pulsando las teclas [Ctrl][Z].");
{
nCarsLeidos = flujoE.read(unNombre, 0, nCarsPorFila);
//****** Si se pulsó [Ctrl][Z], salir del bucle
//****** Añadir el nombre leído a la matriz nombre
nombre[fila] = new char[nCarsLeidos-2]; // menos CR LF
for (int i = 0; i < nCarsLeidos-2; i++)
nombre[fila][i] = unNombre[i]; // copiar
}
flujoS.print("\n\n");
nFilas = fila; //****** número de filas leídas
char respuesta;
do
{
flujoS.print("¿Desea visualizar el contenido de la matriz?
(s/n): ");
} while (respuesta != 's' && respuesta != 'n');
if ( respuesta == 's' )
{
//****** Visualizar la lista de nombres
flujoS.println();
flujoS.println(nombre[fila]);
}

} //**** Fin del try

catch (IOException ignorada) { }
}
}

Ejemplo: La clase CNotas

En el programa CNotas que te presento a continuación se utiliza un arreglo
bidimensional para guardar las notas de N alumnos en M cursos, donde N y M
son valores ingresados mediante el teclado.
En este ejemplo además se utilizan tanto arreglos unidimensionales para guardar
los nombres de los alumnos, los nombres de los cursos y los promedios por
alumno y por curso.
Declaración y creación de arreglos bidimensionales

Para declarar el arreglo bidimensional Notas empleamos la siguiente instrucción:
static double[][] Notas;
Y para crearlo podemos emplear la siguiente sintaxis:
Notas=new double[n][m];
En este programa, al arreglo Notas lo manejamos como una propiedad de la

clase, para que el arreglo Notas sea conocido en todos los métodos.
Ingreso de valores en el arreglo bidimensional

El método LeerNotas() es un ejemplo de cómo se ingresan valores en arreglos
bidimensionales.
Para ingresar valores en este tipo de arreglos se deben utilizar dos bucles
anidados. En este ejemplo utilizamos dos for; pero podemos utilizar también
while o do … while.
public static void LeerNotas()

{
System.out.println("\n******Ingreso de las Notas de los alumnos : ");
for(int i=0;i<n;i++)
{
System.out.println("\nAlumno: "+Nombres[i]);
for(int j=0;j<m;j++)
{
System.out.print("Nota en el curso "+Cursos[j]+" : ");
Notas[i][j]=Lector.nextDouble();
}
}
}
Observa que en el primer for se utiliza el índice i (que representa las filas), de
manera que el arreglo bidimensional se va a recorrer por filas. Y por cada fila
(cada alumno) se va a ir leyendo su nota correspondiente. El segundo for (que
controla las columnas j) tiene como finalidad leer todas y cada una de las notas
del alumno seleccionado.
La instrucción que nos permite ingresar notas a los elementos del arreglo es:

Notas[i][j]= Lector.nextDouble();
Donde i representa la fila y j la columna.
La primera vez que se ingresa al primer for i vale 0 y la primera vez que se
ingresa al segundo for, j vale 0; por lo tanto, el primer elemento que se lee es el
elemento Notas[0,0] , el segundo es el elemento Notas[0,1], Notas[0,2] y así
sucesivamente hasta M cursos.
Una vez que se termina de leer las notas del primer alumno (que corresponden a
la fila 0), se continúa con las notas del segundo alumno (que corresponden a la
fila 1). Es decir, se lee el elemento Notas[1,0] , Notas[1,1], Notas[1,2] y así
sucesivamente hasta M cursos.
Y de esa manera se continúan leyendo las notas de todos los N alumnos.
Ejercicio:
1. Modificar el programa, de manera que permita leer las notas; pero por
curso. En este caso se intercambian los for.
2. Verificar que las notas ingresadas se encuentren en un rango válido (entre
0 y 20 inclusive)
Acceder a los valores almacenados en el arreglo bidimensional
En el método CalcularPromAlumno() vemos un ejemplo de cómo se

accede a los valores almacenados en un arreglo bidimensional.
Para acceder a TODOS los valores almacenados en este tipo de arreglos
se deben utilizar dos bucles anidados. En este ejemplo utilizamos dos for;
pero podemos utilizar también while o do …while.
Y, para calcular el promedio por alumno, el arreglo se debe recorrer
necesariamente por fila.
public static void CalcularPromAlumno()

{
double suma,promedio;
{
suma=0;
{
suma=suma+Notas[i][j];
}
promedio=suma/m;
PromedioAl[i]=promedio;
System.out.println("el promedio del alumno "+Nombres[i]+
" es: "+PromedioAl[i]);
}
}
En este caso, suma y promedio viene a ser variables del método. Y solamente
serán conocidas en este método. Una vez que salimos del método, ya no existen
las variables.

Observa que la variable suma se inicializa en 0 :
suma=0;
antes de entrar al segundo for. Esto es necesario, porque debemos sumar las
notas de cada alumno y antes de sumar sus notas, debemos poner esta variable
en cero. Si no lo hacemos( por ejemplo si ponemos la instrucción antes del
primer for), se acumularían las notas de todos los alumnos.
Observa también que la instrucción:
promedio=suma/m;
Se encuentra después de que ha acabado el segundo for, es decir se calcula el

promedio, sólo después de haber sumado todas las notas del alumno.
Luego, en la instrucción:
Se le asigna al elemento correspondiente del arreglo PromedioAl[i], el valor que

hemos calculado, y como este arreglo se ha declarado como una propiedad de la
clase, los promedios de los alumnos se conocerán en todos y cada uno de los
métodos de la clase.
En el método CalcularPromCurso(), que se utiliza para calcular el promedio por
curso, se recorre el arreglo por columna. Observa que en este caso, se invierte el
orden de los for.
Ejercicio:
Agregar un método al programa, que permita mostrar en la pantalla los
nombres de todos y cada uno de los alumnos, junto con sus notas y sus
promedios.
El programa CNotas completo es el siguiente:
class CNotas
{
static double[][] Notas;
static double[] PromedioAl,PromedioCur;
static String[]Nombres,Cursos;
static int m,n;
public static void LeerNotas()

{
System.out.println("\n******Ingreso de las Notas de los alumnos : ");

{
System.out.println("\nAlumno: "+Nombres[i]);
{
System.out.print("Nota en el curso "+Cursos[j]+" : ");
Notas[i][j]=Leer.datoDouble();
}
}
}
public static void LeerNombres()
{
System.out.println("\n*****Ingreso de los Nombre de los alumnos: ");
{
System.out.print("Alumno :"+i);
Nombres[i]= Leer.dato();
}
System.out.println("\n******Ingreso de los Nombres de los cursos: ");
{
System.out.print("Curso :"+j);
Cursos[j]=Leer.dato();
}
}
public static void CrearMatrices()

{
Nombres=new String[n];
Cursos=new String[m];
Notas=new double[n][m];
PromedioAl=new double[n];
PromedioCur=new double[m];
}
public static void LeerNM()
{
System.out.print("Ingrese la cantidad de alumnos: ");
n=Leer.datoInt();
System.out.print("Ingrese la cantidad de cursos: ");
m=Leer.datoInt();
}
public static void CalcularPromAlumno()
{
{
suma=0;
{

}
promedio=suma/m;
System.out.println("el promedio del alumno "+Nombres[i]+" es:
"+PromedioAl[i]);
}
}
public static void CalcularPromCurso()
{
{
suma=0;
{
}
promedio=suma/n;
PromedioCur[j]=promedio;
System.out.println("el promedio del curso de "+Cursos[j]+" es:
"+PromedioCur[j]);
}
}
public static void main (String[]args)
{
CNotas miObjeto=new CNotas();
System.out.println("**** Programa de ejemplo de arreglos ****");
System.out.println("\nNotas de N alumnos en M cursos\n");
miObjeto.LeerNM();
miObjeto.CrearMatrices();
miObjeto.LeerNombres();
miObjeto.LeerNotas();
miObjeto.CalcularPromAlumno();
miObjeto.CalcularPromCurso();
}
}
Tenga en cuenta que necesita la clase Leer para que pueda funcionar este
programa. Por tanto, debes cargar esta clase que te entrego junto con este
programa a la misma carpeta donde tienes la clase CNotas.
Eso es todo por ahora. Gracias por su atención.

Arrays de Varias Dimensiones Primera Parte

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Arrays de Varias Dimensiones Primera Parte

Diunggah oleh

Hak Cipta:

Format Tersedia

Universidad Los Angeles de Chimbote Sistema de Educación Virtual

ARRAYS DE VARIAS DIMENSIONES

Los vectores examinados hasta ahora se denominan arrays unidimensionales y

Ejemplos típicos de tablas o matrices son tablas de distancias kilométricas entre

arrays bidimensionales (2 dimensiones)

Una matriz mutidimensional, como su nombre lo indica es una matriz de dos o

Matrices numéricas multidimensionales

Tipo [][] ….. nombre_matriz = new tipo [exp.-1][exp.-2] ….. ;

Donde tipo es un tipo primitivo entero o real. El número de elementos de una

int [][] m = new int [2][3] ;

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 1

Evidentemente, el tipo de los elementos de la matriz referenciada por m es int[] y

int [][] m = new int [2][3] ;

Arrays bidimensionales (tablas/matrices)

Si se visualiza un array unidimensional, se puede considerar como una columna

Col.1 Col.2 Col. 3 Col.4 Col. 5 Col. 6

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 2

El diagrama representa una tabla o matriz de treinta elementos (5 x 6) con 5 filas

Un array bidimensional también denominado matriz (términos matemáticos) o

El array B se dice que tiene M x N elementos. Existen N elementos en cada fila y

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 3

escriba las sumas correspondientes a las filas de la matriz. La ejecución del

Número de filas de la matriz: 2

Fin del proceso

En primer lugar definimos las variables que almacenarán el número de filas y

int nfilas, ncols; // filas y columnas de la matriz

Después, creamos la matriz m con el número de filas y columnas especificado,

float[][] m = new float[nfilas][ncols]; //**** crear la matriz m

El paso siguiente es asignar un valor desde el teclado a cada elemento de la

for (fila = 0; fila < nfilas; fila++)

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 4

El programa completo se muestra a continuación:

float[][] m = new float[nfilas][ncols]; //**** crear la matriz m

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 5

float sumafila = 0; //******* suma de los elementos de una fila

System.out.println("Introducir los valores de la matriz.");

//******* Visualizar la suma de cada fila de la matriz

Matrices de cadenas de caracteres

Haciendo un estudio análogo al realizado paras las matrices numéricas

char [ ][ ] nombre_matriz = new char [filas][longitud_fila];

Por ejemplo, la siguiente línea de código crea una matriz de cadenas de

char [ ][ ] m = new char [F][C];

A partir de la línea de código anterior una matriz unidimensional m con los

Evidentemente, el tipo de los elementos de la matriz referenciada por m es char[]

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 6

char[][] m = new char [nFilas][ nCarsPorFila] ;

Pata ilustrar la forma de trabajar con cadenas de caracteres, vamos a realizar un

La solución tendrá el siguiente aspecto:

Número de filas de la matriz: 10

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 7

La solución pasa por realizar los siguientes pasos:

El programa completo se muestra a continuación:

public class CMatriz1Cadenas

//********* Definir una referencia al flujo estándar de salida: flujoS

int nFilas = 0, nCarsPorFila = 0;

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 8

System.out.println("Escriba los nombres que desea introducir.");

El identificador nombre hace referencia a una matriz de caracteres de dos

Siguiendo con el análisis del programa anterior, la entrada de datos finalizará

Curso : Estructuras de datos Docente: Ing. Héctor Fiestas Bancayán 9

El proceso que seguiremos para solucionar el problema planteado es el

char[ ][ ] nombre = new char[nFilas];

No asignamos memoria para cada una de las cadenas porque no

• Leemos las cadenas de caracteres. Para poder leer una cadena,