Вы находитесь на странице: 1из 48

ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Contenido
1. Objetivos ......................................................................................................................................................................... 2
2. Introducción .................................................................................................................................................................... 3
3. Arreglos Unidimensionales (o simplemente arreglos) .................................................................................................... 4
3.1 Concepto ..................................................................................................................................................................... 4
3.2 Declaración ................................................................................................................................................................. 8
3.3 Inicialización ............................................................................................................................................................... 8
3.4 Tamaño ..................................................................................................................................................................... 10
3.5 Acceso a los elementos de un arreglo, recorrido y procesamiento ........................................................................... 11
3.6 Ejercicios de aplicación ............................................................................................................................................ 17
4. Arreglos Bidimensionales o Matrices ........................................................................................................................... 19
4.1 Concepto ................................................................................................................................................................... 19
4.2 Declaración ............................................................................................................................................................... 27
4.3 Inicialización ............................................................................................................................................................. 27
4.4 Tamaño ..................................................................................................................................................................... 30
4.5 Acceso a los elementos de una matriz, recorrido y procesamiento ........................................................................... 31
4.6 Ejercicios de Aplicación ........................................................................................................................................... 37
5. Arreglos Tridimensionales o Cubos .............................................................................................................................. 42
5.1 Concepto ................................................................................................................................................................... 42
5.2 Declaración ............................................................................................................................................................... 44
5.3 Inicialización ............................................................................................................................................................. 44
5.4 Tamaño ..................................................................................................................................................................... 45
5.5 Acceso a los elementos de un cubo, recorrido y procesamiento ............................................................................... 45
6. Arreglos n-dimensionales ............................................................................................................................................. 47

1 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

1. Objetivos

Resumir algunas ideas fundamentales sobre arreglos unidimensionales, bidimensionales (matrices) y n-dimensionales.

Presentar algunos ejemplos generales y específicos sobre arreglos unidimensionales, bidimensionales (matrices) y n-dimensionales.

Enunciar algunos ejercicios generales y específicos sobre arreglos unidimensionales, bidimensionales (matrices) y n-dimensionales.

Relacionar los arreglos unidimensionales, bidimensionales (matrices) y n-dimensionales con la clase ArrayList de lenguaje Java que
encapsula arreglos y oculta el proceso de aumento y reducción de su tamaño.

2 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

2. Introducción

En el curso de Programación Orientada a Objetos (POO) I de Ingeniería de Sistemas, durante el segundo semestre del año 2016, se
identificaron dificultades en el uso de arreglos y matrices, como por ejemplo:

- El estudiante recorre un arreglo usando un ciclo for para acceder al elemento en una posición determinada:
Incorrecto int [ ] diasDelMes = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
for(int i = 0; i < diasDelMes.length; i++){
if(i == mes - 1) {
dias = diasDelMes[i];
break;
}
}
Correcto días = diasDelMes[mes - 1];

- Dados dos arreglos del mismo tamaño, se usa un segundo ciclo for anidado para acceder a un elemento del segundo arreglo
en la misma posición del primero:
Incorrecto int [ ] diaFestivosFijos = {1, 1, 20, 7, 25};//igual tamaño = 5
int [ ] mesFestivosFijos = {1, 5, 7, 8, 12};//igual tamaño = 5
for(int i = 0; i < mesFestivosFijos.length; i++){
if(mes == mesFestivosFijos[i]) {
for(int j = 0; j < diaFestivosFijos.length; j++){
if(j == i)
if(dia == diaFestivosFijos[j])
esFestivoFijjo = true;
}
}
}
Correcto int [ ] diaFestivosFijos = {1, 1, 20, 7, 25};
int [ ] mesFestivosFijos = {1, 5, 7, 8, 12};
for(int i = 0; i < mesFestivosFijos.length; i++){
if(mes == mesFestivosFijos[i]) {
if(dia == diaFestivosFijos[i])
esFestivoFijo = true;
}
}

Considerando ésta dificultad, a continuación se exponen algunas ideas sobre arreglos. En cada capítulo se presentan: concepto,
declaración, inicialización, tamaño y procesamiento, junto con ejemplos y ejercicios.

Nota histórica: Un primer borrador de éste documento se elaboró en noviembre del año 2005 usando el editor de texto StarOffice 6.0.
Dicho borrador fue convertido con la ayuda de Google Docs en la nube y se editó, por lo cual se considera que éste documento es la
version 1.1. Una imagen del FileSystem en mi disco duro lo certifica:

3 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

3. Arreglos Unidimensionales (o simplemente arreglos)

3.1 Concepto

 Un arreglo es un conjunto de datos homogéneos, del mismo tipo y que guardan una relación lógica o conceptual, por lo que se les
referencia usando el mismo nombre o la misma variable. Además, la cantidad de elementos es fija, el tamaño no cambia, es
constante una vez se crea el arreglo. En la memoria del computador los elementos del arreglo se encuentran adyacentes,
contiguos, consecutivos, uno al lado del otro. Ésta relación de adyacencia permite que cada elemento se enumere según su
posición dentro del arreglo, iniciando desde cero (0) hasta una unidad menos que la cantidad de elementos o tamaño del arreglo.
Si el tamaño del arreglo es “n”, los elementos se enumeran desde cero (0) hasta “n – 1”. De éste modo el primer elemento está en
la posición cero (0), el segundo elemento en la posición (1), el tercer elemento en la posición dos (2), el cuarto elemento en la
posición (3) y así sucesivamente hasta el último elemento que se encuentra en la posición “n – 1”. Por ejemplo:

a) El arreglo de las vocales tiene cinco (5) elementos o su tamaño es cinco (5). Cada uno de sus elementos se enumera desde cero (0)
hasta cuatro (4). La vocal “a”, que es la primera vocal, se encuentra en la posición cero (0). La vocal “i”, que es la tercera vocal,
se encuentra en la posición dos (2) y la vocal “u” que es la última o quinta vocal se encuentra en la posición cuatro (4).

b) El arreglo con los días de la semana tiene siete (7) elementos o su tamaño es siete (7): El primer elemento es “Domingo” en la
posición cero (0), el segundo elemento es “Lunes” en la posición uno (1) y así sucesivamente hasta el “Sábado” en la posición
seis (6).

c) El arreglo con la cantidad de días de cada mes del año tiene doce (12) elementos: El mes de abril es el cuarto mes del año, se
encuentra en la posición tres (3) y su contenido es treinta (30) que es la cantidad de días de dicho mes. Febrero es el segundo mes
del año, se encuentra en la posición uno (1) y su contenido es veintiocho (28). De manera similar para los demás meses del año.

4 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

d) El arreglo con los números primos menores que treinta (30) tiene diez (10) elementos o su tamaño es (10): Hay diez (10) números
primos menores que treinta (recuerde que un número primo es aquel que sólo tiene dos divisores, la unidad (1) y él mismo). El
primer número primo es el numero dos (2), en la posición cero (0), el segundo número primo es el tres (3) en la posición uno (1),
el tercer número primo es el cinco (5) en la posición (2) y así sucesivamente. El séptimo número primo es el diecisiete (17) en la
posición seis (6) y el décimo número primo es el veintinueve (29) en la posición nueve (9). Con los números primos se podrían
tener arreglos mucho más grandes, según la capacidad de la memoria del computador.

e) Un polinomio de grado “n” se podría representar usando arreglos. Por ejemplo, el polinomio 3x 7 – 5x5 + 2x3 – x2 + x – 10.
Resulta lógico y conveniente que se almacenen en memoria sólo los coeficientes de cada término del polinomio y no se
almacenen los exponentes. Así mismo, si hay exponentes que el polinomio no contiene, se asume un coeficiente cero (0). Bajo
éstas condiciones el polinomio se puede ver como 3x7 + 0x6 – 5x5 + 0x4 + 2x3 – x2 + x – 10. Además, también es conveniente
reordenar el polinomio para leerlo en orden inverso, desde el exponente cero (0) hasta el exponente “n”. De ésta manera la
posición en el arreglo va a coincidir con el exponente: -10 + x – x2 + 2x3 + 0x4 – 5x5 + 0x6 + 3x7. El cuarto elemento del arreglo
corresponde a la posición tres (3) que es el término 2x 3, así el número dos (2) que es el coeficiente está en la posición tres (3) que
es el exponente.

En la medida que el polinomio tenga pocos o muchos términos puede ser menos o más eficiente usar arreglos para representarlos. Por
ejemplo, el polinomio 17x5 – 5 quedaría con cuatro elementos del arreglo guardando el valor cero (0) y sólo el primer elemento y el
último estarían ocupados.

 Un error frecuente al usar arreglos es confundir la posición de un elemento del arreglo con el número ordinal del elemento. El
número ordinal se usa para contar e inicia en uno (1), en cambio la posición inicia en cero (0), siempre es una unidad menos:
primero (1) = posición cero (0), segundo (2) = posición (1), tercero (3) = posición dos (2), cuarto (4) = posición (3), quinto (5) =
5 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

posición (4), … décimo (10) = posición nueve (9), duodécimo (12) = posición once (11), …, vigésimo (20) = posición diecinueve
(19), … quincuagésimo (50) = posición cuarenta y nueve (49), etc. Por ejemplo, para el arreglo de las vocales:

a) El tercer elemento se encuentra en la posición dos (2) y es la „i‟.

b) El primer elemento se encuentra en la posición cero (0) y es la „a‟.

c) El quinto o último elemento se encuentra en la posición cuatro (4) y es la „u‟.

Es necesario ser siempre muy cuidadoso y diferenciar “el elemento en la posición x” del “elemento número x”. Por ejemplo, “el
elemento en la posición 9” es el “elemento número 10 o décimo elemento”.

6 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

 Otro error frecuente es confundir la posición de un elemento del arreglo con su contenido. Por ejemplo, para el arreglo que
almacena la cantidad de días de cada mes:

a) El noveno mes del año es septiembre, corresponde a la posición ocho (8) y su contenido es treinta (30), que es la cantidad de días
de septiembre.

b) El segundo mes del año es febrero, corresponde a la posición uno (1) y su contenido es veintiocho (28), que es la cantidad de días
de febrero.

 En resumen, los arreglos unidimensionales o simplemente arreglos se pueden distinguir por:


o Conjunto de datos homogéneos, del mismo tipo y con una relación.
o Los elementos del arreglo son adyacentes, contiguos, consecutivos, uno al lado del otro.
o Cada elemento del arreglo tiene una posición, desde cero (0) hasta “n-1” donde “n” es el tamaño del arreglo o la cantidad
de elementos.
o La cantidad de elementos o tamaño del arreglo es constante, no cambia una vez se crea el arreglo.
o No debe confundirse el ordinal con la posición del elemento. El primer elemento (ordinal 1) está en la posición cero (0),
el segundo elemento (ordinal 2) está en la posición uno (1).
o No debe confundirse la posición del elemento con su contenido. La posición de un elemento siempre es un número
consecutivo entre cero (0) y “n-1” donde “n” es el tamaño del arreglo, en cambio, el contenido de un elemento del
arreglo depende del problema específico que se esté resolviendo.

Todo lo explicado hasta aquí es independiente del lenguaje de programación. Algunos lenguajes permiten ignorar la posición cero (0)
para reducir complejidad, pero en la práctica lo mejor es asumir que el primer elemento está en la posición cero (0). A continuación
los detalles de implementación en Lenguaje de Programación Java.

7 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

3.2 Declaración

La sintaxis para declarar un arreglo es igual a la sintaxis de declaración de variables pero agregando después del tipo de dato un par de
corchetes abierto y cerrado [ ].

tipoDeDato [ ] nombreDelArreglo;
char [ ] vocales;
String [ ] diasDeLaSemana;
int [ ] numerosPrimos;
int [ ] diasDeLosMeses;
int [ ] polinomio;

Java también permite la sintaxis de los lenguajes C y C++, con los corchetes [ ] después del nombre del arreglo:

char vocales [ ];

Sin embargo, las reglas de estilo de Java prefieren diferenciarse de C y C++ para enfatizar que el concepto de arreglo implica un tipo
de dato especial, un conjunto de datos.

Al declarar un arreglo su valor por defecto es null, de manera similar a los objetos. En realidad la palabra clave null significa que
no hay un valor asignado. En lenguajes como C y C++ no hay inicialización por defecto, por lo cual hay que ser muy cuidadosos. En
Java, afortunadamente, se puede obviar éste problema.

3.3 Inicialización

Los arreglos se pueden inicializar de tres formas, la tercera es una combinación de las dos primeras:

a) Tipo de Inicialización 1: Sólo se puede usar al mismo tiempo con la declaración. Si se recurre a la teoría matemática de
conjuntos, consiste en describir el conjunto por extension, listando cada uno de sus elementos separados por coma, encerrados
entre llaves { }:

tipoDeDato [ ] nombreDelArreglo = {elemento0, elemento1, elemento2, ..., elementon_1};


char [ ] vocales = { 'a ', 'e ', 'i ', 'o ', 'u '};
String [ ] diasDeLaSemana = {"Domingo", "Lunes", "Martes", "Miércoles", "Jueves",
"Viernes", "Sábado"};
int [ ] numerosPrimos = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29};
int [ ] diasDeLosMeses = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int [ ] polinomio = {-10, 1, -1, 2, 0, -5, 0, 3};

Éste tipo de inicialización es útil, conveniente y apropiada cuando se conocen con anticipación todos los elementos y cuando los
elementos no van a cambiar. También cuando la cantidad de elementos es pequeña y no se justifica escribir un programa para generar
dinámicamente los elementos.

Al usar el componente CodePad del IDE BlueJ, los arreglos se visualizarán verticalmente, a diferencia de las figuras mostradas
cuando se explicó el concepto. En realidad es cuestión de perspectiva y no hay diferencia conceptual.
8 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

b) Tipo de Inicialización 2: En éste caso solo se inicializan los espacios o cajas para los elementos. Consiste en utilizar la palabra
clave new, seguida del tipo de dato e indicando entre corchetes [ ] el tamaño del arreglo:

tipoDeDato [ ] nombreDelArreglo = new [ tamaño];


char [ ] abecedario = new char [27];
int [ ] primerosOnceNumerosPrimos = new int [11];
float [ ] calificaciones = new float [30];

Cuando se usa éste tipo de inicialización, en los arreglos numéricos (byte, short, int, long, float y double) todos los elementos quedan
con valor cero (0), en los arreglos de tipo char todos los elementos quedan con el valor ASCII cero (0) '\u0000' y en los demás tipos
todos los elementos quedan con null. Para poder inicializar cada uno de los elementos del arreglo es necesario escribir un programa
que realice la inicialización, lo cual se explicará cuando se hable sobre cómo procesar arreglos.

Nuevamente, usando BlueJ se puede apreciar lo que ocurre en memoria con éste tipo de inicialización:
9 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

c) Tipo de Inicialización 3: Consiste en mezclar la sintaxis de los dos primeros tipos de inicialización. No es muy frecuente pero
puede ser útil en algunos casos, sobre todo cuando se quiere tener un código organizado en el que siempre las variables se
declaren antes de usarlas.

char [ ] vocales = new char [5];


//Aquí puede haber más código fuente
if(mayuscula) vocales = new char [ ] {'A', 'E', 'I', 'O', 'U'};
else vocales = new char [ ] {'a', 'e', 'i', 'o', 'u'};

3.4 Tamaño

En Java, a diferencia de otros lenguajes como C y C++, los arreglos permiten conocer su tamaño. Es importante recordar que los
arreglos tienen un tamaño constante que no puede modificarse. La sintaxis para acceder al tamaño de un arreglo es similar a como se
accede a las propiedades o métodos de un objeto: se coloca el símbolo punto “.” seguido de la palaba clave “length”. En realidad
“length” no es una palabra clave sino una propiedad interna de los arreglos en Java.
10 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

char [ ] vocales = new char [5];


//Aquí puede haber más código fuente
if(mayuscula) vocales = new char [ ] {'A', 'E', 'I', 'O', 'U'};
else vocales = new char [ ] {'a', 'e', 'i', 'o', 'u'};
int cantidad = vocales.length;

En BlueJ, como ya se apreció en las imágenes anteriores, se puede probar el acceso al tamaño de un arreglo, lo cual es importante para
su procesamiento.

3.5 Acceso a los elementos de un arreglo, recorrido y procesamiento

 Para acceder a un elemento específico de un arreglo se usa el nombre del arreglo y, seguidamente, entre corchetes, la posición del
elemento al cual se quiere acceder. Es importante recordar y comprender los conceptos: el primer elemento está en la posición
cero (0), el segundo en la posición uno (1) y así sucesivamente hasta el último elemento que está en la posición “n-1” donde “n”
es el tamaño del arreglo, es decir “length - 1”. Por ejemplo:

a) En el arreglo de las vocales, para acceder a la tercera vocal se usa la posición dos (2), así:

char terceraVocal = vocales[2];

11 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

b) En el arreglo de la cantidad de días de cada mes, para acceder a cantidad de días de septiembre, que es el noveno mes, se usa la
posición ocho (8), así:

int diasDeSeptiembre = diasDeLosMeses[8];

c) De manera general:

int primerElemento = arreglo[0];//El primer elemento está en la posición 0.


int segundoElemento = arreglo[1];//El segundo elemento está en la posición 1.
int sextoElemento = arreglo[5];//El sexto elemento está en la posición 5.
int elemento17 = arreglo[16];//El elemento 17 está en la posición 16.
int ultimoElemento = arreglo[arreglo.length-1];//El último elemento está en length - 1
int penultimoElemento = arreglo[arreglo.length-2];//Penúltimo elemento está en length – 2
int antePenultimoElemento = arreglo[arreglo.length-3];//posición length - 3

Pero normalmente no se usan arreglos para acceder a una posición específica o a un elemento en particular sino para procesar en
conjunto todos o algunos de los elementos del arreglo, como se explica a continuación.

 Procesar un arreglo consiste en repetir un conjunto de instrucciones para todos o algunos de los elementos del arreglo. Puesto que
los elementos de los arreglos son adyacentes, el procesamiento se puede realizar de dos formas: (i) recorrido hacia adelante,
iniciando en el primer elemento, posición cero (0) y terminando en el último elemento, posición “length -1” o (ii) recorrido hacia
atrás, iniciando en el último elemento, posición “length -1” y finalizando en el primer elemento, posición cero (0). También
podría hablarse de recorrido hacia abajo o hacia arriba, según la perspectiva gráfica del arreglo, por ejemplo en BlueJ es vertical.

12 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

 Puesto que el procesamiento implica repetición se deben usar ciclos. Los ciclos más apropiados y comunes para procesar arreglos
son los ciclos “for”, pero no es una regla de oro y pueden darse situaciones en las que sea preferible usar ciclos while o do/while.
A continuación, de manera general el código para procesar hacia adelante y hacia atrás un arreglo:

Recorrido Hacia Adelante Recorrido Hacia Atrás


 El contador inicia en cero (0), la primera posición, es decir,  El contador inicia en arreglo.length - 1, que corresponde a la
se inicia con el primer elemento. última posición, es decir, se inicia con el último elemento.
 La condición es que el contador sea menor que el tamaño del  La condición es que el contador sea mayor o igual que cero
arreglo, por lo que el ciclo se ejecutará sólo hasta (0), por lo que el ciclo se ejecuta hasta cero (0), que
arreglo.length - 1, que corresponde a la posición del último corresponde a la posición del primer elemento.
elemento.  El contador decrece, retrocede una unidad en cada ciclo, con
 El contador incrementa, avanza una unidad en cada ciclo, lo cual el procesamiento se realiza hacia atrás, desde el
con lo cual el procesamiento se realiza hacia adelante, desde último elemento hacia el primero.
el primer elemento hacia el último.
 En ambos recorridos el procesamiento es igual, es decir, el código interno del ciclo no cambia.
for(int i=0; i<arreglo.length; i++){ for(int i=arreglo.length - 1; i>=0; i--){
//aquí se hace algo con el arreglo //aquí se hace algo con el arreglo
//por ejemplo, imprimir el elemento //por ejemplo, imprimir el elemento
pantalla.imprimir(arreglo[i]); pantalla.imprimir(arreglo[i]);
} }
 Usando ciclos while la única diferencia es la sintaxis, pero lo más apropiado es usar ciclos for.
int i = 0; int i = arreglo.length - 1;
while(i < arreglo.length){ while(i >= 0){
//aquí se hace algo con el arreglo //aquí se hace algo con el arreglo
//por ejemplo, imprimir el elemento //por ejemplo, imprimir el elemento
pantalla.imprimir(arreglo[i]); pantalla.imprimir(arreglo[i]);
i++;//se incrementa el contador i--;//se decrementa el contador
} }

13 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

 Decidir qué recorrido usar depende del tipo de problema que se quiere resolver, del tipo de solución que se quiere implementar y
del estilo personal del programador. Por ejemplo, supóngase que se tiene un arreglo tipo char llamado abecedario, declarado pero
sin inicializar y se quiere inicializar cada elemento con las letras del abecedario según el código ASCII, en mayúscula (la letra 'A'
corresponde al código ASCII 65 y la letra 'Z' al ASCII 90, además, el abecedario en la tabla ASCII está organizado de manera
consecutiva, por lo que un carácter 'char' con una letra se puede usar como número e incrementarla o decrecerla con los
operadores ++ y --, manteniendo el límite para no sobrepasar la 'Z'):

Recorrido Hacia Adelante (inicializar el arreglo) Recorrido Hacia Atrás (inicializar el arreglo)
char [ ] abecedario = new char [26]; char [ ] abecedario = new char [26];
char letra = 'A'; char letra = 'A';
for(int i=0; i<abecedario.length; i++){ for(int i=abecedario.length-1; i>=0; i--){
//aquí se inicializa cada elemento //aquí se inicializa cada elemento
abecedario[i] = letra++; abecedario[i] = letra++;
} }

a) Si se recorre el arreglo hacia adelante el abecedario quedará en orden, con la letra 'A' en la posición cero (0) y a letra 'Z' en la
última posición, la posición 25.

b) Si se recorre el arreglo hacia atrás, el abecedario quedará en orden inverso, con la letra 'Z' en la posición cero (0) y la letra 'A' en
la última posición.

 En el ejemplo anterior el arreglo abecedario se recorrió para inicializar cada uno de sus elementos. Ahora supongamos que el
arreglo ya contiene el abecedario en orden, con la letra 'A' en la posición cero (0) y a letra 'Z' en la última posición, la posición 25
y queremos recorrer el arreglo e imprimirlo en pantalla: con el recorrido hacia adelante se imprimirá en orden de la 'A' a la 'Z' y
con el recorrido hacia atrás se imprimirá en orden inverso, de la 'Z' a la 'A'.

14 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Recorrido Hacia Adelante (imprimir el arreglo) Recorrido Hacia Atrás (imprimir el arreglo)
char [ ] abecedario = new char [26]; char [ ] abecedario = new char [26];
//suponer que está inicializado en orden //suponer que está inicializado en orden
for(int i=0; i<abecedario.length; i++){ for(int i=abecedario.length-1; i>=0; i--){
pantalla.imprimir(abecedario[i]); pantalla.imprimir(abecedario[i]);
} }
Imprime: Imprime:
A Z
B Y
C X
D W
... ...
W D
X C
Y B
Z A

 Ahora supongamos que lo que queremos es convertir el arreglo del abecedario de mayúscula a minúscula. Para las mayúsculas, la
letra 'A' corresponde al código ASCII 65 y la letra 'Z' al ASCII 90. Para las minúsculas, la letra 'a' corresponde al código ASCII
97 y la letra 'Z' al ASCII 122. Como puede apreciarse, la diferencia entre mayúscula y minúscula es de 32, por lo cual la
expresión 'A' + 32 genera la letra 'a' y la expresión 'Z' + 32 genera le letra 'z'. En general, para cualquier letra dentro de ese rango,
letra + 32 genera la misma letra en minúscula. Por ejemplo, la letra 'M' tiene código ASCII 77 y la letra 'm' tiene código ASCII
109. El siguiente es el código con recorrido hacia adelante y hacia atrás que cambia las letras del arreglo abecedario de mayúscula
a minúscula. En éste caso el efecto es el mismo en ambos recorridos y la única diferencia es lo que se imprime, pero en ambos
casos, al finalizar cada recorrido, el arreglo queda con el abecedario en minúscula, en orden, de la 'a' a la 'z'.

Recorrido Hacia Adelante (cambiar a minúscula e imprimir) Recorrido Hacia Atrás (cambiar a minúscula e imprimir)
char [ ] abecedario = new char [26]; char [ ] abecedario = new char [26];
//suponer que está inicializado en orden //suponer que está inicializado en orden
for(int i=0; i<abecedario.length; i++){ for(int i=abecedario.length-1; i>=0; i--){
pantalla.imprimir(abecedario[i]); pantalla.imprimir(abecedario[i]);
abecedario[i] = abecedario[i] + 32; abecedario[i] = abecedario[i] + 32;
pantalla.imprimir(abecedario[i]); pantalla.imprimir(abecedario[i]);
} }
Imprime: Imprime:
A Z
15 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

a z
B Y
b y
C X
c x
D W
d w
... ...
W D
w d
X C
x c
Y B
Y b
Z A
Z A

 Los ejemplos anteriores corresponden a los tres tipos más comunes de operaciones sobre un arreglo, a continuación algunos
ejercicios sencillos.

a) Recorrer el arreglo para inicializar cada uno de sus elementos, aplicando algún procesamiento especial. En el primer ejemplo el
arreglo se inicializó con cada una de las letras del abecedario según el código ASCII. Realice los siguientes ejercicios para éste
tipo de operaciones:
i. Escriba el fragmento de código para inicializar un arreglo de 100 elementos con números aleatorios únicamente pares.
ii. Escriba el fragmento de código para inicializar un arreglo de caracteres únicamente con las consonantes, incluso la Ñ.
iii. Escriba el fragmento de código para inicializar un arreglo de 10 elementos con el valor de “y” en la siguiente función:
y = f(x) = 1/x
Evalúe la función para valores de “x” cercanos a cero, iniciando en 0,5 (1/2) y disminuyendo “x” en 0,05 (1/20). Por
ejemplo:
x 0,5 0.45 0.4 0.35 0.3
y = f(x) = 1/x 2 2,2222 2.5 2.8571 3.3333

iv. Escriba el fragmento de código para inicializar un arreglo con los años bisiestos desde el año 1900 hasta el año 2050.
v. Escriba el fragmento de código para inicializar un arreglo que representa un polinomio de grado “n”, generando
aleatoriamente los coeficientes.

b) Recorrer el arreglo para consultar el valor de algunos o todos los elementos, sin modificarlos. El valor de cada elemento se puede
consultar para imprimirlo o para algún tipo particular de operación. En el segundo ejemplo el arreglo del abecedario se recorrió
para imprimir cada uno de sus elementos. Realice los siguientes ejercicios para éste tipo de operaciones:
i. Escriba el fragmento de código para recorrer un arreglo y calcular la suma de todos sus elementos.
ii. Escriba el fragmento de código para recorrer un arreglo y calcular la suma de los elementos en posición impar.
iii. Escriba el fragmento de código para recorrer un arreglo y calcular la suma de los elementos del arreglo cuyo valor sea
un número par.
iv. Escriba el fragmento de código para recorrer un arreglo y calcular la suma de los elementos del arreglo cuyo valor sea un
número par y se encuentren en una posición impar y los elementos cuyo valor sea un número impar y se encuentren en
una posición par.
v. Escriba el fragmento de código para recorrer un arreglo y averiguar la posición en la que se encuentra un dato. Si el dato
no se encuentra en el arreglo se asume la posición -1.
16 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

c) Recorrer el arreglo para modificar algunos o todos los elementos. En el tercer ejemplo el arreglo del abecedario se recorrió para
convertir de mayúscula a minúscula todos los elementos. Realice los siguientes ejercicios para éste tipo de operaciones:
i. Escriba el fragmento de código para recorrer un arreglo y cambiar cada elemento por la mitad de su valor.
ii. Escriba el fragmento de código para recorrer un arreglo y cambiar cada elemento por la suma de su valor y su posición
en el arreglo.
iii. Escriba el fragmento de código para recorrer un arreglo y cambiar cada elemento por la mitad de su valor si el elemento
se encuentra en posición para y por el doble si el elemento se encuentra en posición impar.
iv. Escriba el fragmento de código para recorrer un arreglo de caracteres y cambiar cada elemento según las siguientes
reglas:
 Si el carácter es una letra en minúscula se cambia a mayúscula y viceversa.
 Si el carácter es un signo “.” se cambia por “,”.
 Si el carácter es un signo “,” se cambia por “.”.
 Si el carácter es un signo “ ” (espacio) se cambia por “$”.
v. Escriba el fragmento de código para incrementar en una unidad el valor de todos sus elementos.

3.6 Ejercicios de aplicación

1. Implemente una clase llamada Polinomio. Dicha clase debe representar internamente el polinomio como un arreglo. Implemente
los métodos getDerivada y getPolinomio, los cuales, respectivamente, regresan la correspondiente derivada e integral pero no
modifican el polinomio. Por ejemplo:
a) Para el polinomio 3x7 – 5x5 + 2x3 – x2 + x – 10
i. El método getDerivada regresa un nuevo polinomio con 21x6 – 25x4 + 6x2 – 2x + 1 y el polinomio inicial no cambia. Al
final hay dos objetos de la clase Polinomio:
 El original, sin cambios 3x7 – 5x5 + 2x3 – x2 + x – 10
 La derivada del polinomio original 21x6 – 25x4 + 6x2 – 2x + 1
b) Para el polinomio 21x6 – 25x4 + 6x2 – 2x + 1
i. El método getIntegral regresa un nuevo polinomio con 3x7 – 5x5 + 2x3 – x2 + x y el polinomio inicial no cambia. Al final
hay dos objetos de la clase Polinomio:
 El original, sin cambios 21x6 – 25x4 + 6x2 – 2x + 1
 La integral del polinomio original 3x7 – 5x5 + 2x3 – x2 + x

2. Implemente una clase llamada Polinomio. Dicha clase debe representar internamente el polinomio como un arreglo. Implemente
los métodos derivar e integrar, los cuales, respectivamente, modifican el polinomio con su correspondiente derivada e integral.
Por ejemplo:
a) Para el polinomio 3x7 – 5x5 + 2x3 – x2 + x – 10
i. El método derivar modifica el polinomio con 21x6 – 25x4 + 6x2 – 2x + 1. Sólo hay un objeto.
b) Para el polinomio 21x6 – 25x4 + 6x2 – 2x + 1
i. El método integrar modifica el polinomio con 3x7 – 5x5 + 2x3 – x2 + x. Sólo hay un objeto.

3. Implemente una clase llamada Ordenador. Dicha clase debe tener dentro de sus propiedades un arreglo de números enteros y
deben implementarse dos métodos de ordenamiento y dos métodos de búsqueda. Investigue acerca de dichos métodos,
compréndalos e impleméntelos. Realice las implementaciones de dos formas, usando ciclos for y usando ciclos while.

17 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

4. Implemente una clase llamada EstadisticoDescriptivo. Dicha clase debe tener dentro de sus propiedades un arreglo de números
enteros y deben implementarse métodos para calcular las siguientes medidas básicas de estadística descriptiva.
a. Media Aritmética o Promedio.
b. Mediana.
c. Moda.
d. Frecuencia de un dato específico. Si el dato no está en el arreglo la frecuencia es cero.

5. Implemente una clase llamada ProcesadorDeTexto. Dicha clase debe tener dentro de sus propiedades un arreglo de caracteres
(char). Deben implementarse métodos convertirMayuscula y convertirMinuscula que modifiquen las letras del abecedario y dejen
sin cambios aquellos caracteres que no son letras del abecedario. Debe considerar la letra Ñ/ñ como una letra.

6. Implemente una clase llamada Depreciador. Dicha clase debe tener dentro de sus propiedades un valor numérico entero que
representa el precio de un bien inmueble y un valor numérico entero que representa los años en los cuales el bien va a ser
depreciado financieramente. Debe implementarse un método getDepreciacion que retorne un arreglo con el valor del bien al
aplicar la depreciación de cada año. Para depreciar use la técnica de “la suma de los dígitos”, como se explica a continuación: Si
el precio del bien es $1.500.000 y se va a depreciar financieramente en 5 años, la “suma de los dígitos de los años” es 15, que se
obtiene al sumar 1 + 2 + 3 + 4 + 5.
a. En el primer año la depreciación es 5/15 * $1.500.000 = $ 500.000, por lo que el bien queda valiendo $1.000.000
b. En el segundo año la depreciación es 4/15*$1.500.000 = $ 400.000, por lo que el bien queda valiendo $ 600.000
c. En el tercer año es 3/15*$1.500.000 = $ 300.000, por lo que el bien queda valiendo $ 300.000
d. En el cuarto año es 2/15*$1.500.000 = $ 200.000, por lo que el bien queda valiendo $ 100.000
e. En el último año o quinto año es 1/15*$1.500.000 = $100.000, por lo que el bien queda valiendo cero pesos $0.

7. Implemente una clase llamada Criptografo. Dicha clase debe tener dentro de sus propiedades un arreglo de caracteres (char).
Deben implementarse dos métodos cifrar y descifrar. El método cifrar convierte cada carácter usando un corrimiento de 17
respecto al código ASCII. Por ejemplo, al cifrar la letra 'A' se vuelve 'R' y al cifrar la letra 'R' se vuelve 'c' y al cifrar la letra 'Z' se
vuelve 'k'. El método descifrar realiza el proceso inverso. Pruebe el programa cifrando su nombre completo.

8. Implemente una clase llamada Vocamero. Dicha clase debe tener dentro de sus propiedades un arreglo de caracteres (char).
Implemente un método convertirVocalEnNumero, que cambie las vocales por números según la siguiente regla de
correspondencia: a=4, e=3, i=1, o=0 y u=5, la correspondencia aplica para mayúsculas, minúsculas y tildes. Por ejemplo,
“murciélago” quedaría “m5rc13l4g0”.

9. Implemente una clase llamada Numerologo. Dicha clase debe tener dentro de sus propiedades un arreglo de caracteres (char).
Implemente un método que calcule la suma del código ASCII de todos los elementos el arreglo. Por ejemplo, para “roma” la suma
de los ASCII es 114+111+109+97=431.

10. Implemente una clase llamada NumeroBinario. Dicha clase debe tomar un número long y generar un arreglo tipo byte con unos
(1) y ceros (0) representando el número en binario.

18 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

4. Arreglos Bidimensionales o Matrices

4.1 Concepto

 Una matriz es un arreglo de arreglos, es decir, una matriz es un arreglo unidimensional cuyos elementos son también arreglos. Por
ejemplo, supongamos que se tienen cuatro arreglos con las vocales en minúscula, mayúscula, con tilde y sin tilde. En lugar de los
cuatro arreglos se puede tener una matriz, es decir, un arreglo de cuatro elementos y cada elemento contiene otro arreglo:

 Por facilidad y por analogía con el mundo real, las matrices se representan gráficamente en dos dimensiones, con filas y
columnas. Cada intersección de una fila y una columna se denomina celda y allí hay un elemento de la matriz.

 Puesto que las matrices son arreglos de arreglos, se mantienen los mismos conceptos. Si se quiere acceder a un elemento de la
matriz hay que indicar dos posiciones: la posición del arreglo principal que corresponde a las filas o posición horizontal y la

19 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

posición secundaria que corresponde a las columnas o posición vertical. Por ejemplo, en la matriz de las vocales, si queremos
acceder a la vocal “ó” debemos referirnos a la posición horizontal o fila 2 y la posición vertical o columna 3.

 En BlueJ se puede apreciar fácilmente el concepto de matriz como un arreglo de arreglos: La matriz de las vocales se aprecia
como un arreglo donde cada elemento contiene una flecha, simbolizando que internamente hay otro arreglo. Si se visualiza el
contenido de cada elemento se aprecian cada uno de los cuatro arreglos de vocales. Sin embargo, BlueJ no permite apreciar la
matriz en filas y columnas, por lo que es importante tener claras las dos representaciones y la abstracción en forma de tabla.

 En la vida real hay muchos escenarios en los cuales las matrices son relevantes:

20 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

a) Un mapa de Google Maps o cualquier otra herramienta de mapas con el trazado de calles y avenidas de una ciudad:

b) La distribución de los carros en un parqueadero.

c) La distribución de las sillas en un avión:

21 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

d) La distribución de los días de la semana, el mes y el año en un calendario.

e) La manera como un albañil acomoda las baldosas de un piso.

f) El reporte de calificaciones de los estudiantes en un curso:

22 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

g) El reporte de consignaciones, retiros y saldo de una cuenta bancaria o cualquier otro conjunto de datos que se pueda representar
como una tabla, en una hoja de cálculo, por ejemplo:

h) Un Sistema de Ecuaciones Simultáneas para resolver matemáticamente cualquier tipo de problemas relacionados con matrices y
en general cualquier sistema de variables en n-dimensiones.

23 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

i) Un juego de ajedrez, o un juego de tetris o un juego de dominó o cualquier juego que implique una abstracción de matriz o forma
de tabla.

j) La distribución de las sillas en una sala de cine:

 El tamaño de una matriz está determinado por la cantidad de filas y columnas. En el ejemplo de las vocales hay cuatro (4)
arreglos, cada uno de cinco (5) elementos, lo que equivale a cuatro (4) filas, cada una de cinco (5) columnas, para un total de
veinte (20) elementos, que corresponde a la multiplicación 4 x 5. Éste cálculo es válido para matrices regulares, que son
cuadradas (igual cantidad de filas y columnas) o rectangulares (diferente cantidad de filas y columnas).

24 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

 No todas las matrices son regulares. Es probable que una fila o una columna sea más grande o más pequeña que otra. Por ejemplo,
si se tiene una matriz de cinco (5) filas y siete (7) columnas para representar en un calendario los días de cada mes de un año,
dicha matriz puede contener máximo 5x7 = 35 elementos. Sin embargo, un mes tiene máximo 31 días, por lo cual se tendrán
celdas vacías.

 En juego de tetris, por ejemplo, se tendrán espacios en blanco en los cuales no hay figuras:

 En matemática existe el concepto de matriz triangular, que consiste en una matriz cuyos valores son cero o vacío para las celdas
cuya fila es mayor o menor que la columna. De manera general se pueden tener matrices triangulares cuando los elementos no
vacíos o diferentes de cero forma un triángulo rectángulo en alguno de los lados de la matriz.

25 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

 En los casos de matrices triangulares y los casos como el calendario hay menos elementos que la capacidad de la matriz, lo que
implica un uso no apropiado de la memoria del computador, en particular cuando se tienen grandes volúmenes de datos. En Java,
el concepto de matrices como arreglos de arreglos minimiza el consumo de memoria RAM, pues cada fila de la matriz puede
contener arreglos de tamaño diferente, permitiendo resolver problemas que impliquen matrices irregulares, como se puede
apreciar usando BlueJ.

26 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

 En resumen, una matriz es un arreglo de arreglos, por lo cual se mantienen todos los conceptos, sintaxis y aplicaciones. La
declaración e inicialización de los arreglos es similar y aplica para las matrices. Un aspecto diferente entre matrices y arreglos es
el manejo de dos dimensiones, filas y columnas y consecuentemente el tamaño de la matriz o cantidad de elementos, que puede
variar según las filas y columnas. Debido a ésta diferencia, el procesamiento de las matrices también varía un poco, pues se
agrega una dimensión generando más posibilidades de recorrido.

4.2 Declaración

La declaración de una matriz es similar a los arreglos: se escribe el tipo de dato seguido de dos pares de corchetes [ ] [ ], simbolizando
el concepto de arreglo de arreglos:

char [ ] [ ] vocales;
int [ ] [ ] calendario;
float [ ] [ ] mapa;
int [ ] [ ] sillasAvion;
float [ ] [ ] calificaciones;
int [ ] [ ] sistemaEcuaciones;

Igual que en los arreglos, al declarar una matriz su valor por defecto es null.

4.3 Inicialización

Aplican los mismos tres tipos de inicialización de arreglos:

a) Tipo de Inicialización 1:

char [ ] [ ] vocales = { {'a', 'e', 'i', 'o', 'u'}, /*fila cero 0*/
{'A', 'E', 'I', 'O', 'U'}, /*fila uno 1*/
{'á', 'é', 'í', 'ó', 'ú'}, /*fila dos 2*/
{'Á', 'É', 'Í', 'Ó', 'Ú'} /*fila tres 3*/
};

int [ ] [ ] matrizTriangular = { {1}, /*fila cero 0*/


{2, 3},
{2, -5, 5},
{1, 3, 2, -1}, /*fila tres 3*/
{1, 3, 2, -1, 3}
};

b) Tipo de Inicialización 2:

char [ ] [ ] vocales = new char [4][5];//Una matriz de 4 filas y cinco columnas


int [ ] [ ] ecuaciones = new int [5][5];//Una matriz de 5 filas y cinco columnas

27 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Las matrices pueden crearse inicializando únicamente las filas y dejando las columnas para inicializarlas posteriormente. En éste caso
se crean sólo las filas, con un valor inicial de null y luego se puede asignar en cada fila un nuevo arreglo.

char [ ] [ ] letras = new char [8][ ];//Una matriz de 8 filas, sin columnas
int [ ] [ ] ecuaciones = new int [5][ ];//Una matriz de 5 filas sin columnas

En cualquier momento de un programa, después de inicializar las filas, se puede asignar un arreglo a una fila de la matriz:

letras[0] = new char [8];//Se inicializa la fila 0 con un arreglo de 8 elementos


letras[1] = new char [7];//Se inicializa la fila 1 con un arreglo de 7 elementos
letras[2] = new char [6];//Se inicializa la fila 2 con un arreglo de 6 elementos

En general, si “m” es una matriz se puede usar la siguiente sintaxis:

m = new tipoDato[totaFilas][ ];//Usar ésta instrucción sólo una vez


m[fila] = new tipoDato[totalColumnasFila];//Repetir ésta instrucción por cada fila

Igual que con los arreglos, no siempre se conocen los elementos de una matriz, así que lo más común es que se requiera algún
algoritmo sencillo que inicialice todos los elementos, el cual involucrará ciclos.
28 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

c) Tipo de Inicialización 3:

char [ ] [ ] vocales = null;


if(tildeFrancesa)
vocales = { {'a', 'e', 'i', 'o', 'u'}, /*fila cero 0*/
{'A', 'E', 'I', 'O', 'U'}, /*fila uno 1*/
{'á', 'é', 'í', 'ó', 'ú'}, /*fila dos 2*/
{'Á', 'É', 'Í', 'Ó', 'Ú'} /*fila tres 3*/
{'à', 'è', 'ì', 'ò', 'ù'}, /*fila cuatro 4*/
{'À', 'È', 'Ì', 'Ò', 'Ù'} /*fila cinco 5*/
};
else
vocales = { {'a', 'e', 'i', 'o', 'u'}, /*fila cero 0*/
{'A', 'E', 'I', 'O', 'U'}, /*fila uno 1*/
{'á', 'é', 'í', 'ó', 'ú'}, /*fila dos 2*/
{'Á', 'É', 'Í', 'Ó', 'Ú'} /*fila tres 3*/
};

Usando la opción de inicializar únicamente las filas y luego inicialar cada fila con un arreglo:

char [ ] [ ] vocales = new char[6];//Por defecto seis (6) filas


//aquí puede ir más código
vocales[0] = {'a', 'e', 'i', 'o', 'u'}; /*fila cero 0*/}
vocales[1] = {'A', 'E', 'I', 'O', 'U'}; /*fila uno 1*/
if(tildeMinuscula)
vocales[2] = {'á', 'é', 'í', 'ó', 'ú'}; /*fila dos 2*/
if(tildeMayuscula)
vocales[3] = {'Á', 'É', 'Í', 'Ó', 'Ú'}; /*fila tres 3*/
if(tildeFrancesaMinuscula)
vocales[4] = {'à', 'è', 'ì', 'ò', 'ù'}; /*fila cuatro 4*/
if(tildeFrancesaMayuscula)
vocales[5] = {'À', 'È', 'Ì', 'Ò', 'Ù'}; /*fila cinco 5*/

Optimizando el código anterior para dejar al final todas las filas vacías:

char [ ] [ ] vocales = new char[6];//Por defecto seis (6) filas


//aquí puede ir más código
int fila = 0;
vocales[fila++] = {'a', 'e', 'i', 'o', 'u'}; /*fila cero 0*/}
vocales[fila++] = {'A', 'E', 'I', 'O', 'U'}; /*fila uno 1*/
if(tildeMinuscula)
vocales[fila++] = {'á', 'é', 'í', 'ó', 'ú'}; /*fila dos 2*/
if(tildeMayuscula)
vocales[fila++] = {'Á', 'É', 'Í', 'Ó', 'Ú'};/*fila tres 2 si tildeMinuscula==false*/

29 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

if(tildeFrancesaMinuscula)
vocales[fila++] = {'à', 'è', 'ì', 'ò', 'ù'};/*según tildeMinuscula y tildeMayuscula */
if(tildeFrancesaMayuscula)
vocales[fila++] = {'À', 'È', 'Ì', 'Ò', 'Ù'};/*según todas las anteriores*/

4.4 Tamaño

En las matrices se tienen tres tamaños diferentes:

a) La cantidad de filas, determinada por el tamaño del arreglo principal. Se obtiene usando “.length”

int [ ] [ ] matrizTriangular = { {1}, /*fila cero 0*/


{2, 3},
{2, -5, 5},
{1, 3, 2, -1}, /*fila tres 3*/
{1, 3, 2, -1, 3}
};
int cantidadFilas = matrizTriangular.length;//

b) La cantidad de columnas de cada fila: Si la matriz es cuadrada o rectangular, todas las filas son del mismo tamaño, pero en
matrices irregulares cada fila tiene un tamaño diferente. Debe averiguarse con “.length” el tamaño de cada fila y debe validarse
que la fila no tenga un valor null, es decir, que la fila no se encuentre vacía:

char [ ] [ ] vocales = { {'a', 'e', 'i', 'o', 'u'}, /*fila cero 0*/
{'A', 'E', 'I', 'O', 'U'}, /*fila uno 1*/
{'á', 'é', 'í', 'ó', 'ú'}, /*fila dos 2*/
{'Á', 'É', 'Í', 'Ó', 'Ú'} /*fila tres 3*/
};
int cantidadFilas = vocales.length;
int cantidadColumnasFila0 = vocales[0]!=null ? vocales[0].length : 0;
int cantidadColumnasFila1 = vocales[1]!=null ? vocales[1].length : 0;
int cantidadColumnasFila2 = vocales[2]!=null ? vocales[2].length : 0;
int cantidadColumnasFila3 = vocales[3]!=null ? vocales[3].length : 0;
boolean esMatrizRegular = cantidadColumnasFila0 == cantidadColumnasFila1 &&
cantidadColumnasFila0 == cantidadColumnasFila2 &&
cantidadColumnasFila0 == cantidadColumnasFila3;
boolean esMatrizCuadrada = esMatrizRegular && cantidadFilas == cantidadColumnasFila0;

c) La cantidad total de elementos de la matriz: Si la matriz es cuadrada o rectangular, se multiplica la cantidad de filas por la
cantidad de columnas. Cuando la matriz es irregular, es necesario recorrer todas las filas y determinar la cantidad de elementos de
cada fila.

La siguiente matriz triangular tiene quince (15) elementos: 1 en la fila 0, dos en la fila 1, 3 en la fila 2, 4 en la fila 3 y 5 en la fila 4.
30 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

int [ ] [ ] matrizTriangular = { {1}, /*fila cero 0*/


{2, 3},
{2, -5, 5*},
{1, 3, 2, -1}, /*fila tres 3*/
{1, 3, 2, -1, 3}
};
int cantidadFilas = matrizTriangular.length;
int cantidadColumnasFila0 = matrizTriangular[0]!=null ? matrizTriangular[0].length : 0;
int cantidadColumnasFila1 = matrizTriangular[1]!=null ? matrizTriangular[1].length : 0;
int cantidadColumnasFila2 = matrizTriangular[2]!=null ? matrizTriangular[2].length : 0;
int cantidadColumnasFila3 = matrizTriangular[3]!=null ? matrizTriangular[3].length : 0;
int cantidadColumnasFila4 = matrizTriangular[4]!=null ? matrizTriangular[4].length : 0;
int cantidadTotalElementos = 0;
boolean esMatrizRegular = cantidadColumnasFila0 == cantidadColumnasFila1 &&
cantidadColumnasFila0 == cantidadColumnasFila2 &&
cantidadColumnasFila0 == cantidadColumnasFila3 &&
cantidadColumnasFila0 == cantidadColumnasFila4;
boolean esMatrizCuadrada = esMatrizRegular && cantidadFilas == cantidadColumnasFila0;
if(!esMatrizRegular)
cantidadTotalElementos = cantidadColumnasFila0 + cantidadColumnasFila1 +
cantidadColumnasFila2 + cantidadColumnasFila3 +
cantidadColumnasFila4;
else
cantidadTotalElementos = cantidadFilas * cantidadColumnasFila0;7

4.5 Acceso a los elementos de una matriz, recorrido y procesamiento

 Para acceder a un elemento específico de una matriz se usa el nombre de la matriz y, seguidamente, entre corchetes, la posición de
la fila y de la columna a la cual se quiere acceder:

char oConTilde = vocales[2][3];

31 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

char uConTilde = vocales[2][4];


char iMayusculaConTilde = vocales[3][2];

 Es importante recordar y comprender que una fila puede estar vacía y que cada fila puede contener una cantidad diferente de
columnas. Dependiendo del problema que se esté trabajando se debe conocer si la matriz es regular (cuadrada o rectangular) o si
es irregular (triangular o una matriz irregular). Por ejemplo, en la siguiente matriz triangular las posiciones marcadas en color rojo
no existen, por lo que se generaría un error si se intenta acceder a dichas posiciones.

int numeroUno = matrizTriangular[0][0];//Correcto


int numeroDesconocido1 = matrizTriangular[0][1];//Incorrecto, elemento no existe
int numeroTres = matrizTriangular[1][1];//Correcto
int numeroDesconocido2 = matrizTriangular[1][2];//Incorrecto, elemento no existe

32 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

 El recorrido de una matriz regular, con igual cantidad de columnas en todas sus filas, independiente de que sea cuadrada (igual
cantidad de filas y columnas) se puede realizar de ocho formas diferentes:

i. Recorrido por filas y columnas, de arriba hacia abajo y de izquierda a derecha.


ii. Recorrido por filas y columnas, de arriba hacia abajo y de derecha a izquierda.
iii. Recorrido por filas y columnas, de abajo hacia arriba y de izquierda a derecha.
iv. Recorrido por filas y columnas, de abajo hacia arriba y de derecha a izquierda.
v. Recorrido por columnas y filas, de izquierda a derecha y de arriba hacia abajo.
vi. Recorrido por columnas y filas, de izquierda a derecha y de abajo hacia arriba.
vii. Recorrido por columnas y filas, de derecha a izquierda y de arriba hacia abajo.
viii. Recorrido por columnas y filas, de derecha a izquierda y de abajo hacia arriba.

Suponiendo que se tiene una matriz de 4 filas y 4 columnas y que se inicializa con los números de 1 a 16 usando los ocho recorridos
anteriores, se generan ocho configuraciones diferentes:

33 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Se deja como ejercicio escribir seis (6) de los ocho (8) métodos y, a continuación se muestran los dos algoritmos de recorrido estándar
i) Recorrido por filas y columnas, de arriba hacia abajo y de izquierda a derecha y v) Recorrido por columnas y filas, de izquierda a
derecha y de arriba hacia abajo.

Recorrido Filas/Columnas Arriba/Abajo - Izquierda/Derecha


 Se requieren dos ciclos for, cada uno con un contador diferente para filas y columnas.
 El primer ciclo inicia el contador de filas en cero (0), la primera posición, es decir, se inicia con la primera fila.
 La condición es que el contador sea menor que la cantidad de filas. El contador de filas se incrementa, avanza una unidad en cada
ciclo, con lo cual el procesamiento se realiza de arriba hacia abajo.
 El segundo ciclo funciona de manera similar pero por columnas y de izquierda a derecha.
int valor = 1;
for(int fila=0; fila < matriz.length; fila++){
for(int columna=0; columna < matriz[0].length; columna++){
//aquí se hace algo con la matriz
//por ejemplo, asignar un valor
matriz[fila][columna] = valor++;
}
}
Se genera la siguiente matriz:

34 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Recorrido Columnas/Filas Izquierda/Derecha - Arriba/Abajo


 Se requieren dos ciclos for, cada uno con un contador diferente para columnas y filas.
 El primer ciclo inicia el contador de columnas en cero (0), la primera posición, es decir, se inicia con la primera columna.
 La condición es que el contador sea menor que la cantidad de columnas. El contador de columnas se incrementa, avanza una
unidad en cada ciclo, con lo cual el procesamiento se realiza de izquierda a derecha.
 El segundo ciclo funciona de manera similar pero por filas y de arriba hacia abajo.
int valor = 1;
for(int columna=0; columna < matriz[0].length; columna++){
for(int fila=0; fila < matriz.length; fila++){
//aquí se hace algo con la matriz
//por ejemplo, asignar un valor
matriz[fila][columna] = valor++;
}
}
Se genera la siguiente matriz:

35 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

 El recorrido de una matriz irregular, con diferente cantidad de columnas en cada fila o de una matriz para la cual no se conoce el
tamaño de sus columnas sólo puede realizarse por filas, de las cuatro primeras formas: No es posible iniciar un recorrido por
columnas pues no se conoce el tamaño con anticipación y se podría generar un error. En general, a continuación la forma más
común de recorrer una matriz de cualquier tipo, usando el recorrido estándar por filas/columnas, arriba/abajo, izquierda/derecha:

Recorrido estándar Filas/Columnas Arriba/Abajo - Izquierda/Derecha


 Se resaltan las validaciones de fila y columna, evitando generar errores de acceso a elementos que no existen
int valor = 1;
for(int fila=0; fila < matriz.length; fila++){
if(matriz[fila] != null){
for(int columna=0; columna < matriz[fila].length; columna++){
//aquí se hace algo con la matriz
//por ejemplo, imprimir el elemento
pantalla.imprimir(matriz[fila][columna]);
}
}
else pantalla.imprimir(“Fila ” + fila + “ está vacía”);
}

 Una aplicación común de matrices es el cálculo de sumatorias de los valores de la matriz, sumando por filas o por columnas. En
éste caso se debe generar un arreglo con el resultado de las sumatorias. A continuación dos métodos de ejemplo que realizan
éstas operaciones sobre una matriz cuadrada o rectangular, similar a lo que se haría en una hoja de cálculo.

36 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Calculo de sumatoria de las filas - Recorrido estándar Filas/Columnas Arriba/Abajo - Izquierda/Derecha


public int[] sumatoriaDeFilas(int [][] matriz)
{
int [] suma = new int [matriz.length];

for(int i=0;i < matriz.length; i++){


for(int j=0;j < matriz[0].length; j++){
suma[i] = suma[i] + matriz[i][j];
}//fin for columnas
}//fin for filas

return suma;
}

Calculo de sumatoria de las columnas - Recorrido estándar Columnas/Filas Izquierda/Derecha - Arriba/Abajo


public int[] sumatoriaDeColumnas(int [][] matriz)
{
int [] suma = new int [matriz.length];

for(int j=0;j < matriz[0].length; j++){


for(int i=0;i < matriz.length; i++){
suma[j] = suma[j] + matriz[i][j];
}//fin for filas
}//fin for columnas

return suma;
}

Es importante dejar claro que la sumatoria de filas y columnas siempre tendrá el mismo valor sin importar el tipo de recorrido que se
use.

4.6 Ejercicios de Aplicación

Los principales usos de las matrices corresponden a problemas matemáticos, en particular problemas de algebra.

1) Programe una clase Matriz según lo que se describe a continuación:

Si se tienen dos matrices “a” y “b”, las matrices “suma” y “resta” cumplen:

suma[i][j] = a[i][j] + b[i][j]

resta[i][j] = a[i][j] - b[i][j]

Dos matrices A y B son multiplicables si el número de columnas de A coincide con el número de filas de B. El elemento C[i][j] de la
matriz producto se obtiene multiplicando cada elemento de la fila i de la matriz A por cada elemento de la columna j de la matriz B y
sumándolos.

37 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

2) Una matriz, según su tamaño, puede ser: C cuadrada(filas = columna), H rectangular horizontal (filas < columnas), V rectangular
vertical (filas > columnas), T triangular superior (la cantidad de elementos de cada fila va reduciendo de uno en uno en la medida
que la fila va aumentando de uno en uno), t triangular inferior (la cantidad de elementos de cada fila va aumentando de uno en
uno en la medida que la fila va aumentando de uno en uno), X cualquier otro tipo de matriz. Escriba un método en la clase matriz
que regrese el tipo de matriz (C, H, V, T, t, X).

public char getTipoMatriz (){return 0;}

3) Dos matrices son iguales si todos sus elemento una a uno son iguales. Aplica sólo para matrices del mismo tipo y el mismo
tamaño. Agregue un método a la clase Matriz que permita comparar una matriz con otra:

public boolean sonIguales(Matriz otraMatriz){return false;}

4) Una matriz es idempotente si al multiplicarla por si misma el resultado es la misma matriz A*A = A. Agregue un método a la
clase Matriz para determinar si es idempotente.

public boolean esIdempotente( ){return false;}


38 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

5) Investigue el método de Gauss para calcular la matriz inversa y agregue un método a la clase Matriz que retorne la matriz inversa.

public Matriz getInversa( ){return null;}

6) Un Robot se puede mover dentro de un plano cuadrado sólo de cuatro formas: hacia la derecha (R), hacia la izquierda (L), hacia
arriba (U) y hacia abajo (D). El plano se representa como una matriz cuadrada de tamaño n x n y los movimientos del Robot se
registran como un arreglo de caracteres que almacena alguna de las letras R, L, U y D, indicando el movimiento realizado. No se
consideran válidos los movimientos por fuera del plano, por lo cual el Robot no ejecuta éstos movimientos. Implemente una clase
Robot que se comporte de acuerdo a las reglas mencionadas y un programa que lea desde el disco duro la posición inicial del
Robot y los movimientos (hasta cien 100) y que informe la posición final del Robot.

7) Al recorrer una matriz cuadrada n*n, con n impar, en forma de “L” se genera una matriz triangular, en forma de pirámide rotada
90° grados, como se muestra en la figura, de tamaño 2*n–1 y n. Escriba un programa que tome una matriz cuadrada n*n, con n
impar y genere la correspondiente matriz triangular realizando el recorrido en forma de “L”. Tenga en cuenta lo siguiente:

 La primera L se obtiene iniciando en la celda [0][0] y finalizando en la celda [n-1][n-1].


 La segunda L se obtiene iniciando en la celda [0][1] y finalizando en la celda [n-2][n-1].
 La tercera L se obtiene iniciando en la celda [0][2] y finalizando en la celda [n-3][n-1].
 Así sucesivamente hasta tener una única celda [0][n-1].

8) Repita el ejercicio anterior pero genere la matriz de manera que la pirámide no esté invertida, como se muestra en la figura.

39 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

9) Se tiene un arreglo con los nombres de los equipos de un torneo de futbol y una matriz cuadrada con los resultados de los partidos
del torneo, que se juega todos contra todos. La posición [i][j] tiene el marcador del partido en el cual el equipo en la posición “i”
fue local y el equipo en la posición “j” fue visitante. De manera similar, la posición [j][i] tiene el marcador del partido en el cual
el equipo en la posición “i” fue visitante y el equipo en la posición “j” fue local. Cualquier posición [i][i] contiene “-1” pues un
equipo nunca juega contra sí mismo. El torneo no permite más de 9 goles para un equipo en un partido, por lo que el marcador se
almacena como un número de dos dígitos, donde el dígito de la izquierda corresponde a lo goles marcados por el equipo local y el
dígito de la derecha corresponde a los goles marcados por el equipo visitante. Por ejemplo, el marcador es 1 – 3 perdiendo el
local, el marcador se almacena como el número 13. La figura muestra un ejemplo de la matriz que almacena los marcadores de
los partidos en un torneo de 5 equipos.

Se requiere un programa que tome como entrada la matriz de resultados de la figura y genere una segunda matriz con la siguiente
información para cada uno de los equipos:

i. Total de Partidos jugados


ii. Número de Partidos ganados de local
iii. Número de Partidos ganados de visitante
iv. Número de Partidos perdidos de local
v. Número de Partidos perdidos de visitante
vi. Número de Partidos empatados de local
vii. Número de Partidos empatados de visitante
viii. Total de Goles a favor
ix. Total de Goles en Contra
x. Gol diferencia (la resta del total de goles a favor y total de goles en contra)
xi. Total de Goles a favor como local
40 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

xii. Total de Goles en contra como local


xiii. Gol diferencia de local (la resta del total de goles a favor como local y total de goles en contra como local)
xiv. Total de Goles a favor como visitante
xv. Total de Goles en contra como visitante
xvi. Gol diferencia de visitante (la resta del total de goles a favor como visitante y total de goles en contra como visitante)
xvii. Puntos Total (3 por ganar y 1 por empatar).

Con la información anterior se necesita imprimir:

- El equipo campeón (el equipo con más puntos) y el equipo que desciende (el equipo con menos puntos).
- El equipo más ofensivo de local (el que más goles hizo de local) y el equipo más ofensivo de visitante (el que más goles hizo
de visitante).
- El equipo con la mejor defensa de local (al que le hicieron menos goles de local) y el equipo con la mejor defensa de visitante
(al que le hicieron menos goles de visitante).
- El equipo que más puntos cedió como local (el de más empates y más partidos perdidos, como local) y el equipo que más
puntos robó como visitante (el de más empates y más partidos ganados, como visitante).
- En caso se empates en puntos para decidir el campeón y el descenso, se decide por: más goles a favor de visitante, menos
goles en contra de local, más puntos robados de visitante, menos puntos cedidos de local.

10) En el popular juego de Tetris (aquí un ejemplo http://www.tetrisfriends.com/games/Marathon/game.php) la mayoría de las figuras
se pueden representar mediante una matriz cuadrada de 3*3 y cada rotación corresponde a rotar 90° grados dicha matriz, como se
aprecia en la figura. Escriba un programa que reciba una matriz de 3*3 con una figura del juego de Tetris y rote la figura 4 veces,
hasta regresar a su versión inicial, mostrando en la pantalla la figura en cada rotación.

41 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

5. Arreglos Tridimensionales o Cubos

5.1 Concepto

Un arreglo tridimensional se puede pensar como varias matrices una encima de otra, formando un cubo, es decir, un arreglo de
matrices. Supongamos que se tienen dos matrices con las vocales, una matriz con las vocales en minúscula y la otra con las vocales en
mayúscula. Las dos matrices pueden formar un arreglo tridimensional. Puesto que las matrices tienen alto y ancho, ahora aparece una
tercera dimensión, la profundidad.

Las principales aplicaciones de los cubos están en la geometría computacional y en gestión de datos (Big Data). Por ejemplo:

a) En aplicaciones de meteorología se pueden requerir arreglos en tres o más dimensiones para generar gráficas como la siguiente:

42 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

b) Las matrices con datos que tienen la misma estructura se pueden almacenar dentro de un arreglo de manera que se puedan
procesar fácilmente.

c) En un juego en tres dimensiones es necesario almacenar grandes cantidades de datos e información geométrica (se combinan los
dos ejemplos anteriores), por ejemplo un laberinto 3D.

43 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

5.2 Declaración

Se usa una declaración similar a los arreglos y las matrices:

char [ ] [ ] [ ] vocales;
float [ ] [ ] [ ] graficaMetereologia;
int [ ] [ ] [ ] laberinto;
int [ ] [ ] [ ] bigData;

5.3 Inicialización

Se mantiene de manera similar a los arreglos y las matrices, pero debe considerarse la profundidad, como tercera dimensión.

char [ ] [ ] [ ] vocales = { {/*La matriz 1, posición cero 3D*/


{'a', 'e', 'i', 'o', 'u'},/*Arreglo 1, posición cero 2D*/
{'á', 'é', 'í', 'ó', 'ú'},
{'à', 'è', 'ì', 'ò', 'ù'},
{'ä', 'ë', 'ï', 'ö', 'ü'}/*Arreglo 4, posición tres 2D*/},
{/*La matriz 2, posición cero 3D*/
{'A', 'E', 'E', 'O', 'U'},/*Arreglo 1, posición cero 2D*/
{'Á', 'É', 'Í', 'Ó', 'Ú'},
{'À', 'È', 'Ì', 'Ò', 'Ù'},
{'Ä', 'Ë', 'Ï', 'Ö', 'Ü'}/*Arreglo 4, posición tres 2D*/}
};

44 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Como lo muestra la gráfica, BlueJ permite ver un cubo como un arreglo de matrices y una matriz como un arreglo de arreglos. En el
ejemplo:
- Lo primero que se visualiza es la profundidad o tercera dimensión, un arreglo de dos posiciones.
- En cada una de las dos posiciones hay una matriz, un arreglo de cuatro arreglos.
- En cada una de las cuatro posiciones hay un arreglo de cinco elementos, las vocales.

Una inicialización tipo 2 implica definir primero el tamaño de la dimensión de profundidad y luego el alto y ancho de las matrices:

char [ ] [ ] [ ] vocales = new char [2][4][5];

5.4 Tamaño

De manera similar se usa “.length”, teniendo en cuenta la tercera dimensión. En el ejemplo de las vocales, en total hay 2*4*5 = 40
elementos. Si se analiza cuidadosamente, hay 2 matrices, cada matriz tiene 4 arreglos y cada arreglo 5 vocales. Normalmente es
necesario aplicar algún tipo de procesamiento al cubo, comenzando siempre por la profundidad, a fin de conocer el tamaño real.

5.5 Acceso a los elementos de un cubo, recorrido y procesamiento

El acceso a un elemento de un cubo implica referenciar siempre la tercera dimensión. En el ejemplo de las vocales, si se quiere
acceder a la È, ésta se encuentra en la posición 1 de la dimensión de profundidad, en la fila 2 y columna 1.

char eMayusculaTildeFrancesa = vocales[1][2][1];

El recorrido de un arreglo tridimensional implica siempre recorrer primero en profundidad, la dimensión 3D y luego recorrer la matriz.
A continuación dos ejemplos, uno con tres ciclos for anidados y otro con un único ciclo que invoca un método para recorrer la matriz.

45 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Ejemplo estándar para recorrer un arreglo tridimensional


public void imprimirCubo1(int [][][] cubo)
{
for(int k=0; k < cubo.length; k++){
if(cubo[k]!=null){
for(int i=0; i < cubo[k].length; i++){
if(cubo[k][i]!=null){
for(int j=0; j < cubo[k][i].length; j++){
imprimir(cubo[k][i][j]);
}//fin for columnas
}//fin if
}//fin for filas
}//fin if
}//fin for profundidad
}//fin imprimirCubo
Ejemplo estándar para recorrer un arreglo tridimensional, invoca un método para recorrer la matriz
public void imprimirCubo2(int [][][] cubo)
{
for(int k=0; k < cubo.length; k++){
if(cubo[k]!=null){
imprimirMatriz(cubo[k]);//El método que se invoca recorre la matriz
}//fin if
}//fin for profundidad
}//fin imprimirCubo

La manera más sencilla de comprender los arreglos tridimensionales es mediante las Hojas de Cálculo. En un libro hay varias hojas de
cálculo, que corresponden a la tercera dimensión. Cada hoja es una matriz, con dos dimensiones. Cada matriz tiene filas y cada fila es
un arreglo de columnas. Cada arreglo de columnas se compone de celdas con los datos.

46 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

6. Arreglos n-dimensionales

De manera general se pueden tener arreglos de muchas dimensiones, según se requiera. Por ejemplo, con varios documentos de hoja
de cálculo se tiene una cuarta dimensión.

En BlueJ se puede probar la siguiente declaración de un arreglo con cuatro dimensiones y se puede apreciar en memoria como un
arreglo de cubos, cada cubo como un arreglo de matrices, cada matriz como un arreglo de arreglos.

char [ ] [ ] [ ] [ ] cuatroDimensiones = new char [2][3][4][5];

47 de 48
ALGUNAS IDEAS SOBRE AREGLOS, MATRICES Y N-DIMENSIONES – Versión 1.5

Profesor: Milton Jesús Vera Contreras miltonjesusvc@ufps.edu.co Noviembre 20 de 2016

Una aplicación de Big Data usando arreglos de muchas dimensiones puede ser el cálculo de estadísticas de Juegos Olímpicos:

 La quinta dimensión representa cada versión de Juegos Olímpicos.


 La cuarta dimensión representa cada deporte.
 La tercera dimensión representa cada país.
 La primera y segunda dimensión corresponden a una matriz cuyas filas representan jugadores y las columnas representan los
puntos obtenidos en cada competición.

En muchos problemas de la vida real que recurren a la matemática y la estadística será necesario usar arreglos de muchas dimensiones
y en todos ellos la base de procesamiento son los arreglos, matrices y cubos, por lo cual es recomendable comprender y ejercitarse.
Cuando se estudien Bases de Datos se aprenderán técnicas especializadas que agilizan el procesamiento de matrices y cubos, de modo
que tener claro el concepto será fundamental.

48 de 48

Вам также может понравиться