Matrices y arrays multidimensionales

Una matriz, o array multidimensional, es una estructura de datos que organiza los elementos en filas, columnas..

Las matrices más comunes son las bidimensionales (2D), que se asemejan a una tabla con filas y columnas, pero también existen matrices tridimensionales (3D) y de mayor dimensión.

¿Cómo funcionan las matrices multidimensionales?

El funcionamiento de las matrices se basa en los siguientes conceptos:

La ilusión de las dimensiones

Hemos definimos una matriz como una estructura de datos de tamaño fijo organizada en dos o más dimensiones (2D, 3D, etc.), donde accedemos a los elementos mediante coordenadas (x, y) o [fila, columna].

int[,] tablero = new int[8, 8]; // Una matriz de 8x8
tablero[0, 5] = 1; // Fila 0, Columna 5

Todo perfecto, marvilloso. Solo hay una “pequeña” pega. La memoria RAM de tu ordenador es una línea continua, no tiene filas ni columnas 🤣.

Para que tú puedas trabajar con [fila, columna], el lenguaje de programación tiene que hacer un truco, linealizar la matriz.

Generalmente, esto se hace colocando las filas una detrás de otra. Es lo que llamamos Row-Major Order.

Sintaxis de matrices en distintos lenguajes

Aunque el concepto es universal, la sintaxis varía según el lenguaje. A continuación, veremos ejemplos en varios lenguajes populares.

using System;

class Program
{
    static void Main()
    {
        // Declarar una matriz 2D de 3 filas y 3 columnas
        int[,] matriz = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 }
        };

        // Acceder a los elementos
        Console.WriteLine(matriz[1, 0]);  // Salida: 4
    }
}

public class Main {
    public static void main(String[] args) {
        // Declarar una matriz 2D de 3 filas y 3 columnas
        int[][] matriz = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 }
        };

        // Acceder a los elementos
        System.out.println(matriz[1][0]);  // Salida: 4
    }
}

# Declarar una matriz 2D de 3 filas y 3 columnas
matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Acceder a los elementos
print(matriz[1][0])  # Salida: 4

// Declarar una matriz 2D de 3 filas y 3 columnas
const matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

// Acceder a los elementos
console.log(matriz[1][0]);  // Salida: 4

Matrices de más de dos dimensiones

Las matrices no se limitan a dos dimensiones. Pueden tener tres o más dimensiones, lo que es útil para representar datos más complejos, como volúmenes 3D o series temporales.

Por ejemplo, así sería una matriz 3D en C#

using System;

class Program
{
    static void Main()
    {
        // Declarar una matriz 3D de 2x3x4
        int[,,] matriz3D = new int[2, 3, 4];

        // Inicializar la matriz
        for (int i = 0; i < 2; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                for (int k = 0; k < 4; k++)
                {
                    matriz3D[i, j, k] = i + j + k;
                }
            }
        }

        // Acceder a los elementos
        Console.WriteLine(matriz3D[1, 2, 3]);  // Salida: 6
    }
}

Matrices dispersas

En el ámbito del cálculo numérico, frecuentemente nos encontramos con matrices donde la gran mayoría de sus elementos poseen son 0 o null. A este tipo de estructura se la denomina Matriz Dispersa.

Si para esto usamos usas una matriz estándar:

1. Ocuparás Terabytes de RAM inútilmente.
2. Pasarás el día procesando ceros que no aportan nada.

Para estos casos, la aritmética de arrays no sirve. Cambiamos de estrategia. En lugar de guardar un array gigante lleno de ceros, guardamos solo los valores que existen.

Hay varias formas. Algunas ideas (sin entrar en mucho detalle, que da para su propio artículo).

# En vez de matriz[1000][500] = 1
galaxia = {}
galaxia[(1000, 500)] = 1