Open In App

Java Program to Find Transpose of Matrix

Last Updated : 24 Mar, 2025
Summarize
Comments
Improve
Suggest changes
Like Article
Like
Share
Report
News Follow

Transpose of a matrix is obtained by changing rows to columns and columns to rows. In other words, the transpose of A[ ][ ] is obtained by changing A[i][j] to A[j][i].

Transpose of a matrix

Example of First Transpose of Matrix

Input: [ [ 1 , 2 , 3 ] ,
[ 4 , 5 , 6 ] ,
[ 7 , 8 , 9 ] ]

Output: [ [ 1 , 4 , 7 ] ,
[ 2 , 5 , 8 ] ,
[ 3 , 6 , 9 ] ]

There are Two cases which we will face while transposing the Matrix as mentioned below:

  • Rectangular Matrix ( Row != Column )
  • Square Matrix ( Row == Column )

Rectangular Matrix

The below program finds the transpose of A[][] and stores the result in B[][]. 

// Java Program to find
// transpose of a matrix

class GFG {
    static final int M = 3;
    static final int N = 4;

    // This function stores transpose
    // of A[][] in B[][]
    static void transpose(int A[][], int B[][])
    {
        int i, j;
        for (i = 0; i < N; i++)
            for (j = 0; j < M; j++)
                B[i][j] = A[j][i];
    }

    // Driver code
    public static void main(String[] args)
    {
        int A[][] = { { 1, 1, 1, 1 },
                      { 2, 2, 2, 2 },
                      { 3, 3, 3, 3 } };

        int B[][] = new int[N][M], i, j;

        transpose(A, B);

        System.out.print("Result matrix is \n");
        for (i = 0; i < N; i++) {
            for (j = 0; j < M; j++)
                System.out.print(B[i][j] + " ");
            System.out.print("\n");
        }
    }
}

Output
Result matrix is 
1 2 3 
1 2 3 
1 2 3 
1 2 3 

The complexity of the above method:

Time Complexity: O(n*m)
Auxiliary Space: O(n*m)

Square Matrix

1. Using Extra Space

The below program finds the transpose of A[][] and stores the result in B[][], we can change N for different dimensions. 

Below is the implementation of the above method:

// Java Program to find
// transpose of a matrix

class GFG {
    static final int N = 4;

    // This function stores transpose
    // of A[][] in B[][]
    static void transpose(int A[][], int B[][])
    {
        int i, j;
        for (i = 0; i < N; i++)
            for (j = 0; j < N; j++)
                B[i][j] = A[j][i];
    }

    // Driver code
    public static void main(String[] args)
    {
        int A[][] = { { 1, 1, 1, 1 },
                      { 2, 2, 2, 2 },
                      { 3, 3, 3, 3 },
                      { 4, 4, 4, 4 } };

        int B[][] = new int[N][N], i, j;

        transpose(A, B);

        System.out.print("Result matrix is \n");
        for (i = 0; i < N; i++) {
            for (j = 0; j < N; j++)
                System.out.print(B[i][j] + " ");
            System.out.print("\n");
        }
    }
}

Output
Result matrix is 
1 2 3 4 
1 2 3 4 
1 2 3 4 
1 2 3 4 

The complexity of the above method:

Time Complexity: O(n2)
Auxiliary Space: O(n2)


2. Transpose of In-Place for Square Matrix

Here in this Method we will swap the elements rather than using some sort of extra space.

Below is the implementation of the above topic:

// Java Program to find
// transpose of a matrix

// Driver Class
class GFG {
    static final int N = 4;

    // Finds transpose of A[][] in-place
    static void transpose(int A[][])
    {
        for (int i = 0; i < N; i++)
            for (int j = i + 1; j < N; j++) {
                int temp = A[i][j];
                A[i][j] = A[j][i];
                A[j][i] = temp;
            }
    }

    // main function
    public static void main(String[] args)
    {
        int A[][] = { { 1, 1, 1, 1 },
                      { 2, 2, 2, 2 },
                      { 3, 3, 3, 3 },
                      { 4, 4, 4, 4 } };

        transpose(A);

        System.out.print("Modified matrix is \n");
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++)
                System.out.print(A[i][j] + " ");
            System.out.print("\n");
        }
    }
}

Output
Modified matrix is 
1 2 3 4 
1 2 3 4 
1 2 3 4 
1 2 3 4 

The complexity of the above method:

Time Complexity: O(n2)
Auxiliary Space: O(1)

Please refer complete article on Program to find transpose of a matrix for more details!



Next Article
Practice Tags :

Similar Reads

three90RightbarBannerImg