C Program For Transpose Of Matrix Using Array

Matrix transposition is a fundamental operation in linear algebra that rearranges a matrix by flipping it over its diagonal. In this article, you will learn how to implement a C program to transpose a matrix using two-dimensional arrays.

Problem Statement

The problem involves taking a given matrix (a rectangular array of numbers) and transforming it into a new matrix where the rows of the original matrix become the columns of the new matrix, and the columns of the original become the rows. This means an element at position (i, j) in the original matrix will move to position (j, i) in the transposed matrix. This operation is crucial in various computational and scientific fields.

Example

Consider an original matrix and its transposed form:

Original Matrix (3x2):

1 2
3 4
5 6

Transposed Matrix (2x3):

1 3 5
2 4 6

Background & Knowledge Prerequisites

To understand and implement matrix transposition in C, readers should be familiar with:

• C Basics: Understanding fundamental data types (int, float), variables, and basic input/output (printf, scanf).
• Arrays: How to declare, initialize, and access elements of single-dimensional arrays.
• Multi-dimensional Arrays: Specifically, two-dimensional arrays (int matrix[rows][cols]) and how to iterate through them using nested loops.
• Loops: for loops are essential for traversing matrix elements.

Use Cases or Case Studies

Matrix transposition is a widely used operation with practical applications across various domains:

• Image Processing: Transposing matrices can be used for rotating images, where pixel data is often represented as a matrix.
• Data Analysis and Machine Learning: In statistical computations and machine learning algorithms (e.g., in calculating covariance matrices, principal component analysis), transposing data matrices is a common step.
• Cryptography: Transposition ciphers rearrange the order of characters in a message, often modeled using matrix operations.
• Computer Graphics: Used in transformations like reflections across arbitrary axes or reorienting coordinate systems.
• Solving Systems of Linear Equations: Certain numerical methods for solving linear equations involve transposing coefficient matrices.

Solution Approaches

For transposing a matrix using C arrays, the most straightforward and common approach involves creating a new matrix to store the transposed elements.

Approach 1: Iterative Transposition with a New Matrix

This approach creates a new matrix of dimensions [cols][rows] and then populates it by assigning original_matrix[i][j] to transposed_matrix[j][i].

One-line Summary Create a new matrix and fill it by swapping row and column indices of the original matrix elements.

Code Example

// Transpose of Matrix
#include <stdio.h>

int main() {
    int rows, cols;

    // Step 1: Get matrix dimensions from the user
    printf("Enter the number of rows: ");
    scanf("%d", &rows);
    printf("Enter the number of columns: ");
    scanf("%d", &cols);

    int originalMatrix[rows][cols];
    int transposedMatrix[cols][rows]; // Transposed matrix will have dimensions cols x rows

    // Step 2: Get elements of the original matrix
    printf("\\nEnter elements of the original matrix:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("Enter element originalMatrix[%d][%d]: ", i + 1, j + 1);
            scanf("%d", &originalMatrix[i][j]);
        }
    }

    // Step 3: Print the original matrix
    printf("\\nOriginal Matrix:\\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            printf("%d\\t", originalMatrix[i][j]);
        }
        printf("\\n");
    }

    // Step 4: Perform transposition
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            transposedMatrix[j][i] = originalMatrix[i][j];
        }
    }

    // Step 5: Print the transposed matrix
    printf("\\nTransposed Matrix:\\n");
    for (int i = 0; i < cols; i++) {
        for (int j = 0; j < rows; j++) {
            printf("%d\\t", transposedMatrix[i][j]);
        }
        printf("\\n");
    }

    return 0;
}

Run

Sample Output

Enter the number of rows: 3
Enter the number of columns: 2

Enter elements of the original matrix:
Enter element originalMatrix[1][1]: 1
Enter element originalMatrix[1][2]: 2
Enter element originalMatrix[2][1]: 3
Enter element originalMatrix[2][2]: 4
Enter element originalMatrix[3][1]: 5
Enter element originalMatrix[3][2]: 6

Original Matrix:
1       2
3       4
5       6

Transposed Matrix:
1       3       5
2       4       6

Stepwise Explanation

1. Get Dimensions: The program first prompts the user to enter the number of rows and columns for the matrix. These values are crucial for declaring the array sizes.
2. Declare Matrices: Two two-dimensional integer arrays are declared: originalMatrix[rows][cols] for the input matrix and transposedMatrix[cols][rows] for the result. Notice that the dimensions of transposedMatrix are swapped (cols then rows) relative to the original.
3. Input Elements: Using nested for loops, the program iterates through each cell of the originalMatrix, prompting the user to enter a value for originalMatrix[i][j].
4. Print Original Matrix: Another set of nested loops prints the originalMatrix in its standard row-column format for verification.
5. Perform Transposition: This is the core logic. Nested for loops iterate through the originalMatrix. Inside the loops, the element originalMatrix[i][j] is assigned to transposedMatrix[j][i]. This swapping of indices i and j is what performs the transposition.
6. Print Transposed Matrix: Finally, nested loops are used again to print the transposedMatrix, which now displays the rows and columns flipped.

Conclusion

Matrix transposition is a fundamental operation with wide applicability, and implementing it in C using arrays is straightforward. By creating a new matrix and simply swapping the row and column indices during element assignment, we can efficiently achieve the transpose. This approach is clear, easy to understand, and suitable for matrices of various sizes.

Summary

• Matrix transposition involves interchanging rows and columns of a matrix.
• An element at (i, j) in the original matrix moves to (j, i) in the transposed matrix.
• C arrays, particularly two-dimensional arrays, are well-suited for representing matrices.
• The most common method uses nested loops to iterate through the original matrix and populate a new, transposed matrix by assigning original_matrix[i][j] to transposed_matrix[j][i].
• This technique is vital in fields like image processing, data analysis, and computer graphics.