Two-Dimensional Arrays in C

Types of Multidimensional Arrays

Arrays in C provide the ability to store data in an organized manner by having several dimensions. Arrays can be of a variety of sizes, but the two most popular kinds are:

1. Two-Dimensional Array (2D Array)

Similar to a table with rows and columns is a two-dimensional array. It allows us to store data in a grid-like format, making it useful for representing matrices, tables, or game boards. It is used in applications where data is arranged in a structured way, such as storing student marks in subjects or representing a chessboard in a game.

Consider the array arr[05][20]:

• The array int arr[05][20] can store total of (05*20) = 100 elements.
• To find the size in bytes, multiply the size of each element (in bytes) by the total number of elements in the array.
• The size of array int arr[05][20] = 05 * 20 * 4  = 400 bytes, where the size of int is 4 bytes.

2. Three-Dimensional Array (3D Array)

A 3D array is basically a 2D array with an additional layer — which makes it great for dealing with increased complexity. Consider it several 2D arrays stacked. It’s frequently used in graphics, scientific computations and simulations. For instance, a 3D array may contain pixel data with varying color layers (RGB).

Declaration and Syntax of 3D Array in C

A three-dimensional (3D) array is an extension of the 2D array, adding another dimension called depth.

Syntax

Type array_name[depth][rows][columns];

Code

int array[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}
    }
};

Code Explanation

• Type: Specifies the data type stored in each element (e.g., int, float).
• Array Name: The identifier used to reference the array.
• Depth: Number of 2D arrays present in the 3D array.
• Rows: Number of rows in each 2D array.‍
• Columns: Number of columns in each 2D array.

A 2D array in C is basically a collection of 1D arrays. This lays out as a grid-like structure and can be referred to as a matrix. Each element in a 2D array is addressed by one of two indices: the row and the column.

Syntax Of A 2D Array In C

data_type array_name[rows][columns];

Example

Declare a two-dimensional array of four rows and three columns of integers in C, we note:

int arr[4][3];

This creates a matrix with three columns and four rows. Every element in the matrix can be accessed by providing its matching row and column indices. 

In C, two-dimensional arrays are organized in a way called row-major order. This means that all the elements of a row are stored right next to each other in memory before the program moves on to the next row. Because of this setup, accessing elements row by row is generally more efficient since they’re located in consecutive memory spaces. On the flip side, if you try to access elements column by column, it can be a bit slower because it involves jumping around to different, non-contiguous memory locations. So, when you're dealing with large datasets or nested loops, understanding this memory layout can really help boost performance.

Contiguous Allocation

In C, two-dimensional arrays are stored in contiguous memory locations, meaning all elements occupy a single, continuous block of memory. This arrangement enables more efficient data access, particularly when traversing the array row by row.

Single Block of Memory

A two-dimensional array is essentially stored as a single block of memory rather than separate memory blocks for each row. This design improves cache locality and improves performance when processing large arrays.

You can initialize a two-dimensional array at declaration time by encapsulating the values inside curly braces. This simplifies populating the array all at once, rather than assigning each element one by one, and makes the array available for use from the beginning.

Code Example

int arr[4][3] = {
    {1, 2, 3},  
    {4, 5, 6},  
    {7, 8, 9},  
    {10, 11, 12}  
};

Explanation Of Code

The array "arr" is arranged in a 3 x 4 matrix (3 rows & 4 columns). Having our data in a “matrix” (i.e., rows and columns) creates a very organized way to view and manage our data. Defining the values in an organized way keeps our code tidy, readable, and easy to read.

To access elements in a 2-D array in C, you need to specify both the row and column positions.

This is done using the syntax:

array_name[row_index][column_index];

When using data in a two-dimensional array, you will likely need to either reference or change individual elements. In C, each element in a 2D array is identified by two indices: one for the row and one for the column. The general syntax for accessing an element is:

array_name[row_index][column_index];

• The first index (row_index) selects the row.
• The second index (column_index) selects the column within that row.

Accessing Elements

By providing the row and column indices of an element, you may get its value. For instance, you would write the following to retrieve the element in the array named matrix's second row and third column: 

int value = matrix[1][2];

The very first row was index 0, the second is index 1, and so on since array indices in C begin at 0. 

Modifying Elements

To change the value of an element of a two-dimensional array, you will need to use the assignment operator with the desired indices. For example, to set the element in the first row and second column of matrix to 10:

matrix[0][1] = 10; 

By providing the proper indices, you can change any element of the array this way.

Example

#include <stdio.h>


int main() {
    // Declaring and initializing a 2x3 matrix
    int arr[2][3] = { {7, 8, 9}, {10, 11, 12} };


    // Printing the original value at second row, third column
    printf("Value at arr[1][2] before change: %d\n", arr[1][2]);


    // Updating the element at second row, third column
    arr[1][2] = 42;


    // Printing the updated value
    printf("Value at arr[1][2] after change: %d\n", arr[1][2]);


    return 0;
}

Output

Value at arr[1][2] before change: 12
Value at arr[1][2] after change: 42

This process allows you to efficiently read and update values stored in any position of a two-dimensional array.

Two-Dimensional Array In C Example

#include <stdio.h>

int main() {
    int arr[3][3] = {  
        {1, 2, 3},  
        {4, 5, 6},  
        {7, 8, 9}  
    };  

    int value = arr[2][1]; // Accessing the element in the third row, second column (value is 8)

    printf("The accessed value is: %d\n", value);  

    return 0;
}

Output

The accessed value is: 8

Explanation Of Code

• arr[2][1] refers to the element in the third row (index 2) and second column (index 1).
• The retrieved value is 8, which is then printed to the console.

Time And Space Complexity

• Time Complexity: Accessing an element in a two-dimensional array takes O(1) time since we use direct indexing (arr[row][col]).‍
• Space Complexity: The space required for a m × n two-dimensional array is O(m × n) because we store m × n elements in contiguous memory. In our example, since we declared a 3×3 array, the space complexity is O(3×3) = O(9) ≈ O(n²).

A 2D array in C is essentially an array of arrays. Internally, the memory for a 2D array is contiguous, meaning all elements are stored one after another in a single block of memory. This helps the computer access elements efficiently.

There are two common ways a 2D array can be stored:

1. Row-Major Order

In row-major order, all the elements from the first row are placed together in memory, followed by the elements of the next row, and so on for each subsequent row. This approach ensures that each row’s data is stored in a continuous block, with rows arranged one after another.

Example:

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

Memory layout in row-major order:

 1, 2, 3, 4, 5, 6

Accessing arr[1][2] means moving past the first row (3 elements) and then 2 elements in the second row to reach 6.

2. Column-Major Order

Column-major order is used in some languages like Fortran. Here, elements of each column are stored consecutively.

Memory layout for the same array in column-major order:

 1, 4, 2, 5, 3, 6

Two-dimensional arrays in C are always kept in row-major order. Understanding this facilitates comprehension of memory allocation, pointer arithmetic, and internal array access.

Traversing a Two-Dimensional Array In C means accessing and processing each element stored in the array. This is done using nested loops, where the outer loop Traversing a Two-Dimensional Array In C means accessing and processing each element stored in the array. Nestled loops are used for this, with the inner loop iterating over the columns and the outer loop iterating through the rows. Here is a simple C program that shows how to traverse and print the elements of a two-dimensional array.

Two-Dimensional Array In C Example

#include <stdio.h>

int main() {
    int arr[4][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
        {10, 11, 12}
    };

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 3; j++) {
            printf("arr[%d][%d] = %d\n", i, j, arr[i][j]);
        }
    }

    return 0;
}

Output

arr[0][0] = 1  
arr[0][1] = 2  
arr[0][2] = 3  
arr[1][0] = 4  
arr[1][1] = 5  
arr[1][2] = 6  
arr[2][0] = 7  
arr[2][1] = 8  
arr[2][2] = 9  
arr[3][0] = 10  
arr[3][1] = 11  
arr[3][2] = 12 

Explanation of the Code

Here we define a Two-Dimensional Array In C arr with rows and columns that initialize it with integer values. The outer for loop runs from i = 0 to i < 4, controlling the rows, while the inner for loop runs from j = 0 to j < 3, controlling the columns. 

Every unique pair of i and j leads to printing the corresponding stored value at arr[i][j], which shows the element at its specific position in the array. The systematic way in which this traverses the array ensures that every component of the array is fixed and printed.

Time and Space Complexity

The time complexity of traversing a two-dimensional array of size m x n is O(m × n), as each element is accessed precisely once. The space complexity is O(1) since no extra space is used apart from the given array.

A Two-Dimensional Array In C can be settled using user input. This provides flexibility in choosing the size of the array and filling it with specific values. An example program prompts the user for the number of rows and columns for two-dimensional array in c, accepts the elements for each position, and prints the filled array.

Input and Output with Two-Dimensional Array Program In C

#include <stdio.h>

int main() {
    int rows, cols;

    printf("Enter number of rows: ");
    scanf("%d", &rows);
    printf("Enter number of columns: ");
    scanf("%d", &cols);

    int arr[rows][cols];

    printf("Enter elements:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("Element [%d][%d]: ", i + 1, j + 1);
            scanf("%d", &arr[i][j]);
        }
    }

    printf("The entered matrix is:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }

    return 0;
}

Output

Enter number of rows: 3
Enter number of columns: 3
Enter elements:
Element [1][1]: 1
Element [1][2]: 2
Element [1][3]: 3
Element [2][1]: 4
Element [2][2]: 5
Element [2][3]: 6
Element [3][1]: 7
Element [3][2]: 8
Element [3][3]: 9
The entered matrix is:
1 2 3 
4 5 6 
7 8 9

Explanation of the Code

In this program, the user is first asked to input the number of rows and columns they want for the two-dimensional array in c. The size of the array is then dynamically set based on the user input. After that, the user is prompted to enter the elements individually.

Each element is stored at the appropriate position in the array. After all elements are entered, the program can now print the entire matrix by checking through each row with its columns in conjunction with elements and print them in a row-oriented manner.

Time and Space Complexity

• The time complexity is O (m × n), since every element of the m×n array has been accessed. 
• Space complexity is O (m × n), the number of elements in the array determines the amount of storage needed.

Passing a two-dimensional array to a function requires specifying at least the second dimension size.

Syntax

return_type function_name(data_type array[][COLS], int rows, int cols);

Code

#include <stdio.h>

void printArray(int arr[][3], int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int matrix[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    
    printf("Matrix elements:\n");
    printArray(matrix, 2, 3);
    
    return 0;
}

Code Explanation

The function printArray(int arr[][3], int rows, int cols) takes a 2D array and its dimensions as input. It loops through the rows and columns to print each element neatly. While passing the array, the first dimension can be left unspecified, but the second dimension must be fixed as [3].

Output

Matrix elements:
1 2 3 
4 5 6

Basically, a 2D array in C is an array of arrays. It enables you to store data in rows and columns that resemble tables. For example, int matrix[3][4]; creates a matrix with 3 rows and 4 columns.

A pointer can be used to access elements of a 2D array efficiently. Because arrays occupy consecutive memory locations, pointers can traverse a 2D array similarly to a 1D array by using calculated memory offsets.

Example: Accessing a 2D Array Using Pointers

#include <stdio.h>
int main() 
{    
int grid[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };    
int (*rowPtr)[3] = grid; // Pointer to a row of 3 integers    
printf("Elements of the grid using pointer:\n");    
for(int r = 0; r < 3; r++) 
{        
for(int c = 0; c < 3; c++) 
{            
printf("%d ", *(*(rowPtr + r) + c)); // Accessing element via pointer        
}        
printf("\n");    
}    
return 0;
}

Explanation of the code:

Here, grid is a 3×3 array of values. Rather than accessing it directly, a pointer rowPtr has pointers to each row. Pointers are used with ordinary arithmetic such that every value can be accessed by its column and row. The loops iterate over all of the rows and columns and output the values, demonstrating the ease with which pointers make dealing with 2D arrays by not having to access the array name repeatedly.

Output:

Elements of the grid using pointer:

1 2 3 
4 5 6 
7 8 9 

Two-dimensional arrays are widely used in C programming due to their versatility in organizing and processing data. Here are some common real-world scenarios and practical examples where 2D arrays shine:

1. Matrix Representation and Operations

Matrices are common in mathematics, engineering, and computer science to name just a few domains. A two-dimensional array will readily represent and operate on matrices for operations such as addition, subtraction, and multiplication.

Example: Adding Two Matrices

#include <stdio.h>

int main(void) {
    /* 1. Define two 2x2 matrices and a result matrix */
    int a[2][2] = { {1, 2}, {3, 4} };
    int b[2][2] = { {5, 6}, {7, 8} };
    int result[2][2];

    /* 2. Add corresponding elements */
    for (int i = 0; i < 2; i++) {          // iterate over rows
        for (int j = 0; j < 2; j++) {      // iterate over columns
            result[i][j] = a[i][j] + b[i][j];
        }
    }

    /* 3. Print the resulting matrix */
    printf("Sum of the matrices:\n");
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }

    return 0;
}

2. Storing Tabular Data

A typical way to store tables such as student grades, sales records or any data that fits into rows and columns of fields is to use two-dimensional arrays.

Example: Storing and Printing Student Marks data

#include <stdio.h>

int main() {
    // Step 1: Declare and initialize two 2x2 matrices
    int a[2][2] = { {1, 2}, {3, 4} };
    int b[2][2] = { {5, 6}, {7, 8} };
    int result[2][2];  // To store the sum

    // Step 2: Add corresponding elements of a and b
    for (int i = 0; i < 2; i++) {          // Loop through rows
        for (int j = 0; j < 2; j++) {      // Loop through columns
            result[i][j] = a[i][j] + b[i][j];
        }
    }

    // Step 3: Print the result matrix
    printf("Sum of the matrices:\n");
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }

    return 0;
}

3. Game Boards

Most board games where a playing grid exists, such as Tic-Tac-Toe, Chess, and Sudoku, use two-dimensional arrays to represent the grid. 

See example: Tic-Tac-Toe Board Initialisation

#include <stdio.h> 
int main() 
{ 
char board[3][3] = { {'X', 'O', 'X'}, {' ', 'X', 'O'}, {'O', ' ', ' '} 
}; 
printf("Tic-Tac-Toe Board:\n"); 
for (int i = 0; i < 3; i++) 
{ 
for (int j = 0; j < 3; j++) 
{ 
printf("%c ", board[i][j]); 
} 
printf("\n"); 
} 
return 0; 
}

4. Image Processing

2D arrays in C are also used for image processing and can be used to store the pixel values, such that each element represents the brightness and/or color of a pixel in the image.

5. Graph Representation

Graphs can also be represented as adjacency matrices, where a 2D array indicates where edges exist (or don’t) exist between nodes. These examples illustrate that two-dimensional arrays in C provide a simplified, yet powerful mechanism by which structured data can be organized, manipulated, and processed in a variety of applications.

The following table compares two-dimensional arrays with other forms of multidimensional arrays in C, highlighting their structures, declarations, and typical use cases.

In C, two-dimensional arrays helps to organize your data and enhance ability to manage it. By understanding how you declare, initialise, access, and iterate through these arrays, programmers will be able to write more efficient and maintainable code. 

Practising with different examples helps strengthen your understanding of two-dimensional array in C and how to apply them effectively in various programming techniques.

1. How to declare a two-dimensional array in C?

You declare it by specifying the data type, name, and size of rows and columns: data_type array_name[rows][columns]; Example: int arr[3][4]; This creates a 2D array with 3 rows and 4 columns.

2. How are elements accessed in a two-dimensional array?

You access an element by specifying the row and column indices: array_name[row_index][column_index]; Example: arr[1][2] refers to the element in the second row, third column.

3. Can a two-dimensional array store different data types in C?

No, it can only store one type of data. If you need different data types, you can use structures or unions, which allow mixing various data types in a single array-like structure.

4. What are the applications of 2D arrays?

Common applications for 2D arrays in C such as image processing, games (for game boards), and scientific computing. It provides an effective way to organize and manipulate complicated data.

5. How can I create a 2D array in C++?

In C++, you can declare a 2D array using the same syntax as in C: data_type array_name[rows][columns]; Alternatively, you can use vectors for dynamic sizing: vector\<vector\<int>> arr(rows, vector\<int>(columns));

6. What common operations can be performed on two-dimensional arrays?

Typical operations consist of traversing individual elements, carrying out mathematical operations such as matrix addition or matrix multiplication, searching for values, and modifying specific elements in a 2D array based on conditions.

‍7. What is the formula for a 2D array in C?

A 2D array's element's address is determined using:

Base_Address + (Row_Index * Number_of_Columns + Column_Index) * Size_of_DataType

8. What is a two-dimensional array also called?

A two-dimensional array is also called a matrix or a table because it stores elements in rows and columns.

‍