Prerequisite: Arrays in C
A multi-dimensional array can be defined as an array that has more than one dimension. Having more than one dimension means that it can grow in multiple directions. Some popular multidimensional arrays are 2D arrays and 3D arrays. In this article, we will learn about multidimensional arrays in C programming language.
Syntax
The general form of declaring N-dimensional arrays is shown below:
type arr_name[size1][size2]….[sizeN];
- type: Type of data to be stored in the array.
- arr_name: Name assigned to the array.
- size1, size2,…, sizeN: Size of each dimension.
Examples
Two-dimensional array: int two_d[10][20]; Three-dimensional array: int three_d[10][20][30];
Size of Multidimensional Arrays
The total number of elements that can be stored in a multidimensional array can be calculated by multiplying the size of both dimensions. Consider the array arr[10][20]:
- The array int arr[10][20] can store total of (10*20) = 200 elements.
To get the size in bytes, we multiply the size of a single element (in bytes) by the total number of elements in the array.
- The size of array int arr[10][20] = 10 * 20 * 4 = 800 bytes, where the size of int is 4 bytes.
Types of Multidimensional Arrays
In C, there can be many types of arrays depending on their dimensions but two of them are most commonly used:
- Two-Dimensional Array (2D Array)
- Three-Dimensional Array (3D Array)
Two-Dimensional (2D) Arrays in C
A two-dimensional array or 2D array is the simplest form of the multidimensional array. We can visualize a two-dimensional array as one-dimensional arrays stacked vertically forming a table with ‘m’ rows and ‘n’ columns. In C, arrays are 0-indexed, so the row number ranges from 0 to (m-1) and the column number ranges from 0 to (n-1).
Declaration of 2D Array
A 2D array with m rows and n columns can be created as:
type arr_name[m][n];
where,
- type: Type of data to be stored in each element.
- arr_name: Name assigned to the array.
- m: Number of rows.
- n: Number of columns.
For example, we can declare a two-dimensional integer array with name ‘arr’ with 10 rows and 20 columns as:
int arr[10][20];
We can initialize a 2D array by using a list of values enclosed inside ‘{ }’ and separated by a comma as shown in the example below:
int arr[3][4] = {0, 1 ,2 ,3 ,4 , 5 , 6 , 7 , 8 , 9 , 10 , 11}
or
int arr[3][4] = {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}};
The elements will be stored in the array from left to right and top to bottom. So, the first 4 elements from the left will be filled in the first row, the next 4 elements in the second row, and so on. This is clearly shown in the second syntax where each set of inner braces represents one row.
In list initialization, we can skip specifying the size of the row. The compiler will automatically deduce it in this case. So, the below declaration is valid.
type arr_name[][n] = {…values…};
It is still compulsory to define the number of columns.
Note: The number of elements in initializer list should always be either less than or equal to the total number of elements in the array.
2D Array Traversal
Traversal means accessing all the elements of the array one by one. An element in two-dimensional array is accessed using row indexes and column indexes inside array subscript operator [].
arr_name[i][j]
where, i and j are row index and column index.
To traverse the whole array, we will use two loops. One loop to go over each row from top to bottom and the other nested inside it to access each element in the current row from left to right.
Example of 2D Array
The below example demonstrates the row-by-row traversal of a 2D array.
C
// C Program to illustrate the 2D array
#include <stdio.h>
int main() {
// Create and initialize an array with 3 rows
// and 2 columns
int arr[3][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
// Print each array element's value
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) {
printf("arr[%d][%d]: %d ", i, j, arr[i][j]);
}
printf("\n");
}
return 0;
}
Outputarr[0][0]: 0 arr[0][1]: 1
arr[1][0]: 2 arr[1][1]: 3
arr[2][0]: 4 arr[2][1]: 5
Time Complexity: O(n * m), where n and m are numbers of rows and columns respectively.
Auxiliary Space: O(1)
How 2D Arrays are Stored in the Memory?
As an array, the elements of the 2D array have to be stored contiguously in memory. As the computers have linear memory addresses, the 2-D arrays must be linearized so as to enable their storage. There are two ways to achieve this:
- Row Major Order: The technique stores the 2D array row after row. It means that the first row is stored first in the memory, then the second row of the array, then the third row, and so on.
- Column Major Column: This technique stores the 2D array column after column. It means that first column is stored first in the memory, then the second column, then the third column, and so on.
This allows the random access to the 2D array elements as the computer need not keep track of the addresses of all the elements of the array. It only tracks of the Base Address (starting address of the very first element) and calculates the addresses of other array elements using the base address.
Passing 2D arrays to functions need a specialized syntax so that the function knows that the data being passed is 2d array. The function signature that takes 2D array as argument is shown below:
returnType funcName (arrType arr_name[m][n], int m, int n)
where m and n are the number of rows and columns. We also need to pass these sizes of rows and columns of the array because an array is always passed as pointers.
Three-Dimensional (3D) Array in C
A Three-Dimensional Array or 3D array in C is a collection of two-dimensional arrays. It can be visualized as multiple 2D arrays stacked on top of each other.
Declaration of 3D Array in C
We can declare a 3D array with x 2D arrays each having m rows and n columns using the syntax shown below:
type arr_name[x][m][n];
- type: Type of data to be stored in each element.
- arr_name: name of the array
- x: Number of 2D arrays. (also called depth of the array)
- m: Number of rows in each 2D array.
- n: Number of columns in each 2D array.
For example,
int arr[2][2][2]
Initialization in a 3D array is the same as that of 2D arrays. The difference is as the number of dimensions increases so the number of nested braces will also increase.
int arr[2][3][2] = {0, 1, 2, 3, 4, 5, 6, 7 , 8, 9, 10, 11}
or
int arr[2][3][2] = { { { 1, 1 }, { 2, 3 }, { 4, 5 } },
{ { 6, 7 }, { 8, 9 }, { 10, 11 } } };
Again, just like the 2D arrays, we can also declare the 3D arrays without specifying the size of the first dimensions if we are using initializer list. The compiler will automatically deduce the size of the first dimension. But we still need to specify the rest of the dimensions.
3D Array Traversal in C
To access an elements in 3D array, we use three indexes. One for depth, one for row and one for column.
arr_name[d][i][j]
where, d, i and j are the indexes for depth (representing a specific 2D array.), the row within that 2D array, and the column within that 2D array respectively.
To traverse the entire 3D array, you need to use three nested loops: an outer loop that goes through the depth (or the set of 2D arrays), a middle loop goes through the rows of each 2D array and at last an inner loop goes through each element of the current row.
C
// C program to print elements of a Three-Dimensional Array
#include <stdio.h>
int main() {
// Create and Initialize the 3-dimensional array
int arr[2][3][2] = { { { 1, 1 }, { 2, 3 }, { 4, 5 } },
{ { 6, 7 }, { 8, 9 }, { 10, 11 } } };
// Loop through the depth
for (int i = 0; i < 2; ++i) {
// Loop through the rows of each depth
for (int j = 0; j < 3; ++j) {
// Loop through the columns of each row
for (int k = 0; k < 2; ++k)
printf("arr[%i][%i][%i] = %d ", i, j, k,
arr[i][j][k]);
printf("\n");
}
printf("\n\n");
}
return 0;
}
Outputarr[0][0][0] = 1 arr[0][0][1] = 1
arr[0][1][0] = 2 arr[0][1][1] = 3
arr[0][2][0] = 4 arr[0][2][1] = 5
arr[1][0][0] = 6 arr[1][0][1] = 7
arr[1][1][0] = 8 arr[1][1][1] = 9
arr[1][2][0] = 10 arr[1][2][1] = 11
How 3D Arrays are Stored in the Memory?
Like 2D arrays, the elements of a 3D array should also be stored contiguously in memory.
Since computers have linear memory, the 3D array must also be linearized for storage. We use the same two techniques, the Row Major Order and Column Major Order but with added dimension. The elements are first stored layer by layer (or 2D array by 2D array). Within each 2D array, the elements follow the corresponding row or column major order.
Passing a 3D array to a function in C is similar to passing 2D arrays, but with an additional dimension. When passing a 3D array, you need to pass the sizes of all the dimensions separately because the size information of array is lost while passing.
returnType funcName (arrType arr_name[d][m][n], int d, int m, int n)
Conclusion
We discussed multidimensional array with two examples, the 2D and 3D arrays. The methods which we learned here can be extended to work with arrays with any number of dimensions. However, the complexity also increases as the number of dimensions increases.
Similar Reads
C Arrays
An array in C is a fixed-size collection of similar data items stored in contiguous memory locations. It can be used to store the collection of primitive data types such as int, char, float, etc., and also derived and user-defined data types such as pointers, structures, etc. Array DeclarationIn C,
9 min read
Properties of Array in C
An array in C is a fixed-size homogeneous collection of elements stored at a contiguous memory location. It is a derived data type in C that can store elements of different data types such as int, char, struct, etc. It is one of the most popular data types widely used by programmers to solve differe
8 min read
Length of Array in C
The Length of an array in C refers to the maximum number of elements that an array can hold. It must be specified at the time of declaration. It is also known as the size of an array that is used to determine the memory required to store all of its elements. In C language, we don't have any pre-defi
3 min read
Multidimensional Arrays in C - 2D and 3D Arrays
Prerequisite: Arrays in C A multi-dimensional array can be defined as an array that has more than one dimension. Having more than one dimension means that it can grow in multiple directions. Some popular multidimensional arrays are 2D arrays and 3D arrays. In this article, we will learn about multid
10 min read
Initialization of Multidimensional Array in C
In C, multidimensional arrays are the arrays that contain more than one dimensions. These arrays are useful when we need to store data in a table or matrix-like structure. In this article, we will learn the different methods to initialize a multidimensional array in C. The easiest method for initial
4 min read
Jagged Array or Array of Arrays in C with Examples
Prerequisite: Arrays in CJagged array is array of arrays such that member arrays can be of different sizes, i.e., we can create a 2-D array but with a variable number of columns in each row. These type of arrays are also known as Jagged arrays. Example: arr[][] = { {0, 1, 2}, {6, 4}, {1, 7, 6, 8, 9}
3 min read
Pass Array to Functions in C
Passing an array to a function allows the function to directly access and modify the original array. In this article, we will learn how to pass arrays to functions in C. In C, arrays are always passed to function as pointers. They cannot be passed by value because of the array decay due to which, wh
3 min read
How to pass a 2D array as a parameter in C?
A 2D array is essentially an array of arrays, where each element of the main array holds another array. In this article, we will see how to pass a 2D array to a function. The simplest and most common method to pass 2D array to a function is by specifying the parameter as 2D array with row size and c
3 min read
How to pass an array by value in C ?
In C programming, arrays are always passed as pointers to the function. There are no direct ways to pass the array by value. However, there is trick that allows you to simulate the passing of array by value by enclosing it inside a structure and then passing that structure by value. This will also p
2 min read
Variable Length Arrays (VLAs) in C
In C, variable length arrays (VLAs) are also known as runtime-sized or variable-sized arrays. The size of such arrays is defined at run-time. Variably modified types include variable-length arrays and pointers to variable-length arrays. Variably changed types must be declared at either block scope o
2 min read