Two-Dimensional Arrays in C

A multidimensional array in C is an array that has more than one dimension. Instead of storing values in a single line like a one-dimensional array, it arranges data in a structured format, similar to a table or a grid.

Syntax

The general form for declaring N-dimensional arrays is outlined below:

Type array_name[size1][size2]...[sizeN];

Code

#include <stdio.h>

int main() {
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    // Printing the array elements
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

Code Explanation

• Type: Specifies the data type of the array elements (e.g., int, float).
• Array Name: The identifier used to reference the array.
• Size of Each Dimension: Defines the number of elements each dimension can hold.

Types of Multidimensional Arrays

In C, arrays can have more than one dimension, meaning they can store data in a structured way. While arrays can have multiple dimensions, the two most commonly used types are:

1. Two-Dimensional Array (2D Array)

A two-dimensional array is like a table with rows and columns. 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 three-dimensional array adds another layer to a 2D array, making it useful for handling more complex data structures. Think of it as multiple 2D arrays stacked together. It is commonly used in graphics, scientific computations, and simulations. For example, a 3D array can store pixel data with different color layers (RGB).

Declaration 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 two-dimensional array in c is essentially a collection of one-dimensional arrays arranged in a structured format of rows and columns. This forms a grid-like structure that is commonly referred to as a matrix. Each element in a 2D array is identified using two indices: the row number and the column number.

Syntax Of A 2D Array In C

data_type array_name[rows][columns];

Here, data_type specifies the type of elements stored in the array (e.g., int, float, char), array_name is the chosen name of the array, and [rows][columns] defines the number of rows and columns.

Example

To declare a two-dimensional array in c of integers with 4 rows and 3 columns, we note:

int arr[4][3];

This creates a matrix with 4 rows and 3 columns, where each element can be accessed using its row and column index.

In C, two-dimensional arrays are stored in row-major order, meaning that all row elements are placed next to each other in memory before moving to the next row. This arrangement confirms that accessing elements row-wise is more efficient because they are stored in consecutive memory locations. On the other hand, accessing elements column-wise can be slower, as it requires jumping across non-contiguous memory locations. When working with large datasets or nested loops learning this memory layout helps optimize performance.

Contiguous Allocation

Two-dimensional arrays in C are stored in contiguous memory locations. This means that all elements are placed in a single memory block, making data access faster when iterating row-wise.

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.

A two-dimensional array in C can be initialized at the time of declaration by specifying values for each element in a structured format. This helps assign values to the array without manually setting each component individually.

Code Example

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

Explanation Of Code

• arr is a two-dimensional array with 4 rows and 3 columns (a 4×3 matrix).
• Each row contains three elements, making it easy to represent data in a table-like format.
• The values are assigned in a structured manner, so the code is more readable and organized.

Elements in a Two-Dimensional Array In C are accessed using their row and column indices. The general syntax for accessing an element is:

array_name[row_index][column_index];

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²).

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 iterates through the rows, and the inner loop iterates through the columns. 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. 

For each combination of i and j, the value stored at arr[i][j] is printed, displaying the element and its respective position in the array. This structured traversal ensures that every array component is accessed and printed systematically.

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.

Two-Dimensional Array Program In C Example

#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. Once all elements are entered, the program prints the entire matrix by iterating through the rows and columns and displaying each element in a row-wise format.

Time and Space Complexity

• Time complexity: O(m × n), The program must visit each element of the array, where m is the number of rows and n is the number of columns.
• Space complexity: O(m × n), The space used depends on the size of the 2D array, which is determined by the number of rows and columns.

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

• Function Definition: printArray(int arr[][3], int rows, int cols) accepts a 2D array and its dimensions as arguments.
• Looping through Rows and Columns: The function prints each element in a structured format.
• Passing the Array: The array is passed to the function without specifying the first dimension, but the second dimension must be fixed ([3]).

Output

Matrix elements:
1 2 3 
4 5 6

Two-Dimensional Array In C is used in various practical applications across different fields. Here are some essential examples,

1. Matrix Representation

In mathematics and computer science, two-dimensional arrays are used to represent matrices. This allows for the efficient storage and manipulation of numbers in rows and columns, essential for performing calculations in areas such as linear algebra.

2. Game Development

Many board games, such as Tic-Tac-Toe or Chess, use two-dimensional arrays to represent the game grid. Each element in the array corresponds to a cell in the grid, making it easier to track the game's progress and check for win conditions.

3. Image Processing

Two-dimensional arrays play an essential role in image processing, where each pixel in an image can be stored as an element in the array. The array's rows and columns represent the image’s height and width, with each element containing information like color or brightness levels.

4. Data Tables

In applications like spreadsheets, two-dimensional arrays store and organize data in rows and columns. This structure allows for easy access, editing, and manipulation of data, such as in databases or statistical analysis tools.

5. Graph Representation

In computer science, two-dimensional arrays are commonly used to represent graphs through an adjacency matrix. This matrix helps store the relationships between nodes in a graph and it is easier to apply graph algorithms for tasks like finding paths or identifying connected components.

Two-dimensional arrays in C programming provide an organized way to store and manage data efficiently. Developers can write more efficient and maintainable code by learning to declare, initialize, access, and iterate through these arrays.

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 do you 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?

2D arrays are used in areas like image processing, game development (for game boards), and scientific computing. They help with efficient data organization and complex manipulations.

5. How to 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?

Common operations include traversing elements, performing mathematical operations like matrix addition or multiplication, searching for values, and modifying specific elements based on conditions.