Hola estimados lectores ¿Qué les ha parecido el curso? Si tienen oportunidad comenten acerca de su experiencia con é, así como también si tienen alguna duda. Con gusto les apoyaré. Ahora bien, continuemos con el siguiente capítulo. En el artículo anterior se dio inicio a las estructuras de arreglos con el tema Array I: Arreglos Unidimensionales, se le ha llamado unidimensionales precisamente por eso: Se expanden en una sóla dimensión, es decir, si indicamos el tamaño del arreglo ésta tendrá n cantidad de posiciones dirigidos en una misma dirección.
Todo esta bien, existen muchas cosas que pueden modelarse mediante un simple arreglo, pero en ocasiones requeriremos más de una dimensión para almacenar datos con características similares; en estos casos usaremos arreglos de más de una dimensión: Arreglos Multidimensionales.
Arreglos Multidimensionales
Cuando hablamos de arreglos multimendionales se hace referencia a cualquier array cuya dimensión es mayor a uno. Sin embargo, para fines prácticos y por estar más cercano a ejemplos cotidianos, estudiaremos arreglos de dos dimensiones, los cuales también pueden ser llamados Vectores.
Los vectores son arreglos de dos dimensiones (bidimensionales) cuya referencia a las posiciones se hacen a través de una dirección horizontal (columnas) y otra vertical (filas). Su sintaxis es la siguiente:
[tipo de dato] nombre_del_arreglo [tamaño_fila][tamaño_columna] (= {dato1, dato2,...,datoNxM} valor (opcional));
La sintaxis es similar al arreglo unidimensional con la salvedad que se debe indicar no sólo un tamaño sino dos: Uno para la fila y otro para la columna; adicionalmente si se inicializará con valores algunos valores estos se deben colocar unos tras otro (separados por coma). Un vector se representa gráficamente así:
Para asignar o extraer una datos dentro de un vector es necesario indicar tanto su fila como su columna. De esta maneras nos ubicamos en la posición deseada y manipulamos el dato. Es mejor que veamos un caso para entender mejor esta estructura:
#include <stdlib.h>
#include <iostream>
using namespace std;
int main (){
float vector [2][2] = {2, 3, 4, 5};
vector[0][1] = 5;
for (int i = 0; i < 2; i++){
for (int j = 0; j < 2; j++){
cout << "-" << vector [i][j];
}
}
return 0;
}
En el ejemplo anterior vemos los siguiente:
- Declaración del vector con valores iniciales: Se ha creado una vector 2x2, cuyos valores iniciales son los descritos entre llaves.
- Luego modifica un dato en la posición de la fila 0 y columna 1 vector[0][1] = 5.
- Para recorrer por completo un vector utilizaremos la estructura de control for anidado. Vean que encontramos dos for, el primero utiliza como índice la variable i y el más interno la variable j. El funcionamiento es el siguiente, primero se ejecuta en el primer for y se verifica si la condición se cumple; para la primera vez la variable i es igual a cero (i=0), por lo que sí se cumple, permitiendo que se ejecute el segundo for. Acá también se evalúa la condición de j < 2; lo que hará que se recorra el vector dejando fijo la fila en 0 y moviendo la columna. Una vez que se recorra por completo toda la columna se incrementa la fila (variable i) y la variable j es reinicializada en cero. Así ocurrirá hasta que se haya paseado por todo el vector.
- Para este caso se recorre todo el vector para mostrar sus valores.
Creo que ahora podemos agregarle un poco de dificultad a esto (aunque no considero sea difícil si le agarras el ritmo). El enunciando es el siguiente: Realizar un programa que cree una matriz cuadrada de un tamaño definido por el usuario. Le solicite al mismo los valores que rellenará la matriz y por último se muestre los valores de la diagonal principal.
#include <stdlib.h>
#include <iostream>
using namespace std;
int main (){
int tam;
cout << "Ingrese el tamaña del vector: ";
cin >> tam;
float vector [tam][tam];
//Insercción de los Datos
for (int i = 0; i < tam; i++){
for (int j = 0; j < tam; j++){
cout<<"Ingrese un dato para la posición "<<i<<","<<j<<": ";
cin >> vector [i][j];
}
}
cout << "Los valores de la Diagonal Principal de la matriz es "<<endl;
for (int i = 0; i < tam; i++){
for (int j = 0; j < tam; j++){
if (i == j){
cout <<" | "<< vector[i][j];
}
}
}
return 0;
}
¿Les pareció complicado el ejercicio? Fíjense que aplicando un poco de lógica y lo que hemos visto hasta ahora los resolvemos. Qué tal si lo analizamos:
- El ejercicio le pide al usuario que indique el tamaño de una matriz cuadrada, esto significa que tanto su fila como columna es del mismo tamaña; por ese motivo se le solicita la usuario que indique un solo dato para el tamaño, cuyo valor es guardado en la variable tam.
- Esa variable es usada para declarar al array vector[tam][tam]. Se declaró float para dar libertad a ingresar números con decimales.
- Luego se colocan los for anidados para solicitar al usuario los datos de serán asignados al vector.
- Más adelante se utiliza la misma estructura de for anidados para recorrer el arreglo. Dentro de esta estructura se insertó un if, esto es necesario para que se imprima solo los valores de la Diagonal Principal. La Diagonal de una matriz es aquella donde sus índices son iguales; esto es: Los índices de la fila y columna son iguales (i==j). Es por eso que con el if se condiciona que cuando esto ocurra se imprima el valor del vector.
Con respecto a vectores se pueden aplicar muchos otros ejercicios interesantes. Les aseguro que haré un Apéndice con varios ejercicios hechos. Ya damos por concluido este capítulo de arreglos, pero antes les quiero dejar las siguientes observaciones:
- A pesar de haber estudiado como Arreglos Multidimensionales con vectores bidimensionales, es posible crear arreglos de multidimensiones. Hasta ahora no he conseguido límites para ello, claro siempre he creado arreglos cuyos dimensiones son razonables. Recuerda que las variables y arreglos utilizan tu memoria RAM como espacio de almacenamiento y éste componente físico sí es limitado.
- Es casi como una fórmula fija que para recorrer un arreglo completo utilizar un for anidado. El nivel de anidación dependerá de la dimensión del arreglo. Es por ello que si tenemos un arreglo de una dimensión usamos una sola estructura for. Si es bidimensional utilizamos dos for y así sucesivamente.
- Recomiendo utilizar siempre for para recorrer un arreglo. Note que se puede ajustar una estructura while para recorrer un arreglo. Pero lo más práctico es usar el for.
0 comentarios:
Publicar un comentario