2D Arrays in One Shot | C Programming | Lecture 8

Two Dimensional Arrays in C are used to store data in a row-and-column format, making them ideal for representing tables, matrices, and grids. Instead of managing multiple related arrays, you can organize information efficiently within a single structure. In this article, you will learn the basics of Two Dimensional Arrays in C, including declaration, initialization, data access, and common matrix operations.

What is a Two Dimensional Array in C?

When writing code to handle high-volume data structures, standard linear lists often fall short. If you need to store simple multi-variable sheets, like student marks across several subjects or chess board squares, linear arrays can limit your structural efficiency.

A grid storage approach offers an efficient workaround. Two dimensional arrays in C serve as data structures configured inside a structural block containing rows and columns. Often referred to as a matrix, this multi-tiered architecture functions like an internal structural table.

Instead of writing individual memory references, you can cluster information within a continuous data arrangement. Every item inside this multi-level data system occupies a specific structural cell, making lookups simple and direct.

Syntax and Initialization of Two Dimensional Arrays in C

Setting up a matrix requires a dual-index allocation format. The initial bracket sets the total vertical rows, while the second determines the horizontal columns.

You can define and fill these matrices using a few different methods depending on your code structure.

1. Separate Nested Element Mapping

You can directly target specific index coordinates within your data matrix to load values one cell at a time.

C

int basic_matrix[2][2];
basic_matrix[0][0] = 1;
basic_matrix[0][1] = 2;
basic_matrix[1][0] = 3;
basic_matrix[1][1] = 4;

2. Inner Grouped Row Declarations

Using nested braces clarifies the layout of your data matrix by keeping rows grouped and easy to read.

C

int grouped_matrix[2][3] = {
    {10, 20, 30},
    {40, 50, 60}
};

3. Flat Inline Declarations

You can also define the grid linearly. The compiler uses your specified column size to automatically wrap data into rows.

C

int flat_matrix[2][3] = {10, 20, 30, 40, 50, 60};

4. Open Row-Size Definitions

If you initialize the matrix immediately, you can omit the row size. The compiler deduces it by dividing your total elements by the column size.

C

int open_matrix[][3] = {1, 2, 3, 4, 5, 6}; // Deduces a 2x3 layout

Reading Matrix Data in Two Dimensional Array in C

To build dynamic matrices, you can use loops to collect size configurations and element values directly from user inputs.

The configuration layout below shows how to request matrix dimensions, process inputs using scanning functions, and display the completed data structure.

C

#include <stdio.h>
int main() {
    int rows, cols;
    printf("Enter total grid rows: ");
    scanf("%d", &rows);
    printf("Enter total grid columns: ");
    scanf("%d", &cols);
    int user_matrix[rows][cols];
    printf("Enter grid values:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            scanf("%d", &user_matrix[i][j]);
        }
    }
    printf("\nYour Data Matrix Layout:\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d ", user_matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

Matrix Operations Using Two Dimensional Arrays in C 

Once your data grid is populated, you can perform multiple computations, including calculations, searches, and spatial data modifications.

1. Matrix Addition Operations

To add two matrices, they must have identical row and column dimensions. The process adds matching positions from each grid and saves the sum to a third matrix.

The block below demonstrates how to combine two separate source grids into a final output matrix.

C

#include <stdio.h>
int main() {
    int alpha[2][2] = {{1, 2}, {3, 4}};
    int beta[2][2]  = {{5, 6}, {7, 8}};
    int sum_matrix[2][2];
   
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            sum_matrix[i][j] = alpha[i][j] + beta[i][j];
        }
    }
    printf("Result Matrix Output:\n");
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            printf("%d ", sum_matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

2. Accumulating Whole-Grid Aggregates

This approach loops through every coordinate in the matrix to calculate a single total value from all stored components.

C

int total_sum = 0;
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        total_sum += matrix[i][j];
    }
}

Advanced Transformations in Two Dimensional Arrays in C 

Advanced array operations require careful index shifting to handle complex tracking and structural rotations.

1. Matrix Transpose Transformation

Transposing a matrix swaps its rows and columns, turning its vertical stacks into horizontal sequences.

C

// Standard Transpose using a distinct target matrix
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        transposed_matrix[j][i] = original_matrix[i][j];
    }
}

For square matrices, you can transpose the data in place by swapping values across the diagonal axis. This method reduces memory usage by eliminating the need for a secondary grid.

C

// In-Place Square Grid Transposition loop logic
for (int i = 0; i < grid_size; i++) {
    for (int j = i; j < grid_size; j++) {
        int temp = matrix[i][j];
        matrix[i][j] = matrix[j][i];
        matrix[j][i] = temp;
    }
}

2. Executing 90-Degree Clockwise Matrix Rotations

Rotating a matrix 90 degrees clockwise requires two steps: first, transpose the grid, and then reverse the elements in each row.

C

// Step 1: Perform an in-place transposition swap
for (int i = 0; i < n; i++) {
    for (int j = i; j < n; j++) {
        int temp = grid[i][j];
        grid[i][j] = grid[j][i];
        grid[j][i] = temp;
    }
}
// Step 2: Reverse elements row by row
for (int i = 0; i < n; i++) {
    int start = 0;
    int end = n - 1;
    while (start < end) {
        int temp = grid[i][start];
        grid[i][start] = grid[i][end];
        grid[i][end] = temp;
        start++;
        end--;
    }
}

Two Dimensional Arrays in C for Matrix Multiplication

Multiplying matrices requires strict matching dimensions. The column count of your first matrix must exactly equal the row count of your second matrix.

The code example below establishes the proper structural checks and loop controls needed to calculate a matrix dot-product.

C

#include <stdio.h>

int main() {
    int r1 = 3, c1 = 2; // Matrix A Dimensions
    int r2 = 2, c2 = 4; // Matrix B Dimensions
    int A[3][2] = {{1, 2}, {3, 4}, {5, 6}};
    int B[2][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}};
    // The columns of A must match the rows of B
    if (c1 != r2) {
        printf("Multiplication check failed.\n");
        return 0;
    }
    int result[3][4] = {0};
    // Processing calculations via three nested index tracking loops
    for (int i = 0; i < r1; i++) {
        for (int j = 0; j < c2; j++) {
            for (int k = 0; k < c1; k++) {
                result[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    printf("Multiplication Product Output:\n");
    for (int i = 0; i < r1; i++) {
        for (int j = 0; j < c2; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    return 0;
}