Matrices

A matrix is an interesting topic. Memory is just one dimensional. It helps to see how multidimensional matrices live in memory.

The core data structure is the array. When you declare a matrix, nested arrays represent it.

array and matrix used interchangeably

Keep in mind that matrices and arrays mean the same thing here. They're the same. Programming languages also use arrays to build matrices.

how arrays are used to represent matrices

• A one dimensional matrix is a plain array. Its values are primitives.
• A two-dimensional matrix is an array of arrays. Its values are pointers to the inner arrays.
• A three-dimensional matrix is array of arrays.

You can nest this to any depth.

finding size of matrices

To find the size of a matrix in each dimension, you must know its structure in terms of the inner arrays.

Mental model for multidimensional matrices

Learn how 1D and 2D matrices live in memory. The rest just nest more layers on top. Whatever the size, the real data sits in a 1-D matrix. That's just an array. And an array is a continuous block of memory holding primitive values.

N dimensional matrix mental model

An N dimensional array is an array whose elements are N-1 arrays. This repeats until the elements are primitive types.

For a 3D matrix, picture a cube of many layers. Each layer is a 2D array.

For a 2D matrix, picture a flat plank of many small blocks. Each block is a 1D array.

int[][][] A = {
    {   // A[0] (first level)
        {  1,  2,  3,  4 },   // A[0][0] (second level)
        {  5,  6,  7,  8 },   // A[0][1]
        {  9, 10, 11, 12 }   // A[0][2]
    },
    {   // A[1]
        { 13, 14, 15, 16 },  // A[1][0]
        { 17, 18, 19, 20 },  // A[1][1]
        { 21, 22, 23, 24 }   // A[1][2]
    }
};

int[][][][] A = {
    {   // A[0] (first level)
        {   // A[0][0] (second level)
            {  1,  2 },      // A[0][0][0] (third level)
            {  3,  4 },      // A[0][0][1]
            {  5,  6 }       // A[0][0][2]
        },
        {   // A[0][1]
            {  7,  8 },      // A[0][1][0]
            {  9, 10 },      // A[0][1][1]
            { 11, 12 }       // A[0][1][2]
        }
    },
    {   // A[1]
        {   // A[1][0]
            { 13, 14 },
            { 15, 16 },
            { 17, 18 }
        },
        {   // A[1][1]
            { 19, 20 },
            { 21, 22 },
            { 23, 24 }
        }
    }
};