Tutorial de Programación en C de Linux Parte 24 - Arreglos multidimensionales

Si estás siguiendo esta serie de tutoriales de programación en C, estarías al tanto del concepto de arreglos. Para refrescar rápidamente, los arreglos se utilizan para almacenar múltiples valores del mismo tipo en un almacenamiento continuo.

Arreglos multidimensionales en C

Por ejemplo, el siguiente es un arreglo de enteros capaz de almacenar 5 números.

int arr[5]

Cualquier valor almacenado en un arreglo se puede acceder fácilmente utilizando el nombre del arreglo y el valor del índice correspondiente. Dado que los índices comienzan desde 0, digamos que si quieres acceder al segundo elemento en un arreglo, puedes hacerlo de la siguiente manera:

arr[1]

El siguiente programa acepta 5 enteros del usuario como entrada, los almacena en un arreglo y luego los devuelve al usuario.

#include   
  
int main()  
{  
 int arr[5],i;  
   
 printf("Ingresa 5 valores enteros\n");  
   
 for(i=0;i<5;i++)  
 scanf("%d",&(arr[i]));  
   
 printf("Has ingresado los siguientes valores:\n");  
   
 for(i=0;i<5;i++)  
 printf("%d\n",arr[i]);  
   
  
 return 0;  
}

Ahora, este tipo de arreglo se conoce como un arreglo unidimensional. Sí, eso significa que también existen arreglos multidimensionales: arreglos bidimensionales, arreglos tridimensionales, y así sucesivamente. Por ejemplo, el siguiente es un arreglo bidimensional:

int arr[2][3]

Puedes visualizar este arreglo como una tabla de números en 2-D con 2 filas y 3 columnas, algo así como lo siguiente:

x x x  
x x x 

Así que hay un total de 6 elementos que este arreglo puede contener. Vale la pena mencionar que el número total de elementos que un arreglo puede contener se puede calcular fácilmente multiplicando los índices en la declaración del arreglo. Por ejemplo, en el caso de ‘arr’, la capacidad del arreglo se puede calcular haciendo 2x3, que es igual a 6.

Pasando a la parte de inicialización, un arreglo 2-D como ‘arr’ se puede inicializar de la siguiente manera:

int arr [2][3] = {1,2,3,4,5,6}

Como esta inicialización anterior hace que sea difícil visualizar estos valores en un arreglo 2-D, hay otra (lea: mejor) manera que puedes optar. Aquí está:

int arr [2][3] = { {1,2,3}, {4,5,6} };

Así que ahora es fácil visualizar que los números 1,2,3 están en una fila, mientras que 4,5,6 están en la otra. Aquí tienes:

1 2 3  
4 5 6

En cuanto a cómo tratar con un arreglo 2-D en C, el siguiente es un pequeño programa que acepta estos 6 valores del usuario, los almacena en un arreglo 2-D ‘arr’, y luego finalmente los devuelve al usuario:

#include   
  
int main()  
{  
   int arr[2][3],i,j;  
   
   printf("Estás a punto de ingresar valores para un arreglo 2x3\n");  
   
   for(i=0;i<2;i++)  
   {  
     for(j=0;j<3;j++)  
     {  
       printf("\n Ingresa el valor a almacenar en la fila %d y columna %d :: ",i,j);  
       scanf("%d",&arr[i][j]);  
     }  
   }  
   
   printf("\n Has ingresado los siguientes valores:\n");  
   
   for(i=0;i<2;i++)  
   {  
     for(j=0;j<3;j++)  
     {  
       printf("\n Fila %d y columna %d = %d\n",i,j,arr[i][j]);  
     }  
   }  
   
  return 0;  
}

Y aquí está la salida:

Estás a punto de ingresar valores para un arreglo 2x3   
   
 Ingresa el valor a almacenar en la fila 0 y columna 0 :: 1   
   
 Ingresa el valor a almacenar en la fila 0 y columna 1 :: 2   
   
 Ingresa el valor a almacenar en la fila 0 y columna 2 :: 3   
   
 Ingresa el valor a almacenar en la fila 1 y columna 0 :: 4   
   
 Ingresa el valor a almacenar en la fila 1 y columna 1 :: 5   
   
 Ingresa el valor a almacenar en la fila 1 y columna 2 :: 6   
   

Has ingresado los siguientes valores:   
   
 Fila 0 y columna 0 = 1   
   
 Fila 0 y columna 1 = 2   
   
 Fila 0 y columna 2 = 3   
   
 Fila 1 y columna 0 = 4   
   
 Fila 1 y columna 1 = 5   
   
 Fila 1 y columna 2 = 6

Así que esa fue alguna información básica sobre arreglos bidimensionales. ¿Qué pasa con los arreglos tridimensionales? Bueno, en las mismas líneas, también puedes definir e inicializar arreglos tridimensionales. Aquí hay un ejemplo:

int arr[2][3][4]

Entonces, ¿cómo se visualizaría este arreglo? Bueno, piensa en un mundo tridimensional (el mundo en el que vivimos), y luego visualiza tres dimensiones perpendiculares entre sí. Así es como encajan las tres dimensiones de este arreglo.

Con una capacidad de 24 elementos (2x3x4), este arreglo se puede inicializar de la siguiente manera:

int x[2][3][4] =  
 {  
   { {1,2,3,4}, {5,6,7,8}, {9,10,11,12} },
   { {13,14,15,16}, {17,18,19,20}, {21,22,23,24} }
 };

Y aquí hay un programa en C que utiliza un arreglo 3-D:

#include   
  
int main()  
{  
   int arr[2][3][4],i,j,k;  
   
   printf("Estás a punto de ingresar valores para un arreglo 2x3x4\n");  
   
   for(i=0;i<2;i++)  
   {  
     for(j=0;j<3;j++)  
     {  
       for(k=0;k<4;k++)  
       {  
          printf("\n Ingresa el valor a almacenar en arr[%d][%d][%d] :: ",i,j,k);  
          scanf("%d",&arr[i][j][k]);  
       }  
     }  
   }  
   
 printf("\n Has ingresado los siguientes valores:\n");  
   
   for(i=0;i<2;i++)  
   {  
     for(j=0;j<3;j++)  
     {  
       for(k=0;k<4;k++)  
       {  
          printf("\n arr[%d][%d][%d] = %d\n",i,j,k,arr[i][j][k]);  
       }  
     }  
   }  
   
  return 0;  
}

Conclusión

En este tutorial, ampliamos nuestra comprensión existente de los arreglos al discutir el concepto de arreglos multidimensionales. Se te aconseja probar los ejemplos utilizados en este tutorial en tu sistema (así como crear nuevos) para obtener una mejor comprensión de cómo funcionan estos arreglos. En caso de cualquier duda o consulta, deja un comentario a continuación.