Open In App

Java Program to Find Transpose of Matrix

Last Updated : 25 Mar, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

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 
// Java Program to find
// transpose of a matrix

class Geeks 
{
    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

Explanation: In the above code, we have a matrix where the row is not equal to the column (Rectangular Matrix) so if we want to make the transpose of it we need to change rows with columns. So here we are creating another matrix (extra space) to store the transpose matrix and simply swap the rows with column and store it in a new matrix.

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 
// Java Program to find
// transpose of a matrix

class Geeks
{
    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

Explanation: In the above example, we have a matrix where the number of rows is equal to the number of columns now we are using the same approach as we followed in the previous program we swap the rows A[i][j] with columns A[j][i] and we are storing it in the another array.

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 
// 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

Explanation: In the above code, we have a matrix where the number of columns is equal to the number of rows so here, we can make a transpose without creating another matrix we can directly store it in the same matrix here, we simply swap the rows with columns A[i][j] = A[j][i] and reduce the space.

The complexity of the above method:

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

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


Next Article
Java Program to Find the Determinant of a Matrix
author
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox