Rotate A Matrix By 180 Degree in Java

In this section, we will discuss how to rotate a matrix by 180 degree in Java. In this problem, a square matrix is given, and we have to rotate it by 180⁰.

Example 1:

Input:

4 6 7 8

9 3 2 1

9 0 4 5

8 0 3 2

Output:

2 3 0 8

5 4 0 9

1 2 3 9

8 7 6 4

Approach to Rotate a Matrix by 180 Degree

There are various approaches to solve the problem but, in this section, we will discuss the following approaches:

Naive Approach
Using Transpose Matrix
By Swapping of Positions

Let's start with the simplest approach first.

Naive Approach

Consider the above examples. We observe that we are printing the rows of the input matrix in the reverse order starting from the bottom-most row and going upwards.

For example, if an input array has the 5 rows, then the 5^th row is printed first. After that, the 4^th row is printed, then the 3^rd row is printed, and so on.

Let's see the implementation of the simplest approach.

FileName: RotateMatrix.java

public class RotateMatrix
{

// method that prints all
// the rows in a given matrix by rotating it by 180 degrees
public void printMatrix(int matrix[][], int row, int col)
{
    // picking up the rows of the input matrix one by one in the
    // the bottom up manner.
    for(int j = row - 1; j >= 0; j--)
    {
        
         // loop for printing the rows in the reverse order
        for(int i = col - 1; i >= 0; i--)
        {
            System.out.print(matrix[j][i] + " ");
        }
 
        System.out.println();
    }
}
// main method
public static void main(String argvs[])
{
//creating an object of the class RotateMatrix
RotateMatrix obj = new RotateMatrix();
// input matrix
int matrix[][] = {{ 4, 6, 7, 8 },
                  { 9, 3, 2, 1 },
                  { 9, 0, 4, 5 },
                  { 8, 0, 3, 2 }
                };
// row length of the matrix          
int row = matrix.length;
// column length of the matrix
int col = matrix[0].length;
System.out.println("For the following matrix: ");
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("The rotated matrix at 180 degree is: ");
obj.printMatrix(matrix, row, col);
System.out.println("\n");
// input matrix
int matrix1[][] = {{ 4, 7, 8, 6, 7 },
                  { 9, 2, 1, 9, 1 },
                  { 9, 0, 5, 4, 3 },
                  { 5, 6, 7, 2, 1 },
                  { 8, 9, 0, 5, 1 }
                };

// row length of the matrix          
row = matrix1.length;
// column length of the matrix
col = matrix1[0].length;
System.out.println("For the following matrix: ");
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
System.out.print(matrix1[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("The rotated matrix at 180 degree is: ");
obj.printMatrix(matrix1, row, col);
System.out.println("\n");
}
}

Output:

For the following matrix: 
4 6 7 8 
9 3 2 1 
9 0 4 5 
8 0 3 2 

The rotated matrix at 180 degree is: 
2 3 0 8 
5 4 0 9 
1 2 3 9 
8 7 6 4 

For the following matrix: 
4 7 8 6 7 
9 2 1 9 1 
9 0 5 4 3 
5 6 7 2 1 
8 9 0 5 1 

The rotated matrix at 180 degree is: 
1 5 0 9 8 
1 2 7 6 5 
3 4 5 0 9 
1 9 1 2 9 
7 6 8 7 4

Using Transpose Matrix

The following algorithm depicts how one can use the concept of the transpose of the matrix to solve the problem.

Step 1: Compute the transpose of the given matrix.

Step 2: Reverse the column of the transposed matrix.

Step 3: After reversing the column in the previous step, find the transpose of the matrix again.

Step 4: Reverse the column of the matrix found in step 3.

For example, if we have an input matrix as:

14 27 38 46 57

79 52 31 39 11

99 80 15 24 43

45 56 97 82 51

78 79 60 25 41

Then its transpose will be

14 79 99 45 78

27 52 80 56 79

38 31 15 97 60

46 39 24 82 25

57 11 43 51 41

Now, we will reverse its columns

57 11 43 51 41

46 39 24 82 25

38 31 15 97 60

27 52 80 56 79

14 79 99 45 78

Again, we will transpose the matrix.

57 46 38 27 14

11 39 31 52 79

43 24 15 80 99

51 82 97 56 45

41 25 60 79 78

Again, we will reverse its columns.

41 25 60 79 78

51 82 97 56 45

43 24 15 80 99

11 39 31 52 79

57 46 38 27 14

The following program depicts the implementation of the above approach.

FileName: RotateMatrix1.java

public class RotateMatrix1
{
    // Method for reverse the columns of the matrix arr
    public void reverseMatrixColumns(int arr[][], int r, int c)
    {
        for (int j = 0; j < c; j++) {
            for (int i = 0, m = c - 1; i < m; i++, m--) {
                int t = arr[i][j];
                arr[i][j] = arr[m][j];
                arr[m][j] = t;
            }
        }
    }
// method to transpose the input matrix
public void findTranspose(int a[][], int R, int C)
{
for (int j = 0; j < R; j++) 
{
    for (int i = j; i < C; i++) 
    {
        int t = a[j][i];
        a[j][i] = a[i][j];
        a[i][j] = t;
    }
}
}
// method that prints all
// the rows of the given matrix 
public void printMatrix(int a[][], int r, int c)
{
for (int j = 0; j < r; j++) 
{
    for (int i = 0; i < c; i++)
    {
        System.out.print(a[j][i] + " ");
    }
    System.out.println();
}
}
// main method
public static void main(String argvs[])
{
//creating an object of the class RotateMatrix1
RotateMatrix1 obj = new RotateMatrix1();
// input matrix
int matrix[][] = {{ 4, 6, 7, 8 },
                  { 9, 3, 2, 1 },
                  { 9, 0, 4, 5 },
                  { 8, 0, 3, 2 }
                };
// row length of the matrix          
int row = matrix.length;
// column length of the matrix
int col = matrix[0].length;
System.out.println("For the following matrix: ");
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("The rotated matrix at 180 degree is: ");
// step 1
obj.findTranspose(matrix, row, col);
// step 2
obj.reverseMatrixColumns(matrix, row, col);
// step 3
obj.findTranspose(matrix, row, col);
// step 4
obj.reverseMatrixColumns(matrix, row, col);
obj.printMatrix(matrix, row, col);
System.out.println("\n");
// input matrix
int matrix1[][] = {{ 4, 7, 8, 6, 7 },
                  { 9, 2, 1, 9, 1 },
                  { 9, 0, 5, 4, 3 },
                  { 5, 6, 7, 2, 1 },
                  { 8, 9, 0, 5, 1 }
                };
// row length of the matrix          
row = matrix1.length;
// column length of the matrix
col = matrix1[0].length;
System.out.println("For the following matrix: ");
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
System.out.print(matrix1[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("The rotated matrix at 180 degree is: ");
// step 1
obj.findTranspose(matrix1, row, col);
// step 2
obj.reverseMatrixColumns(matrix1, row, col);
// step 3
obj.findTranspose(matrix1, row, col);
// step 4
obj.reverseMatrixColumns(matrix1, row, col);
obj.printMatrix(matrix1, row, col);
System.out.println("\n");
}
}

Output:

For the following matrix: 
4 6 7 8 
9 3 2 1 
9 0 4 5 
8 0 3 2 

The rotated matrix at 180 degree is: 
2 3 0 8 
5 4 0 9 
1 2 3 9 
8 7 6 4 

For the following matrix: 
4 7 8 6 7 
9 2 1 9 1 
9 0 5 4 3 
5 6 7 2 1 
8 9 0 5 1 

The rotated matrix at 180 degree is: 
1 5 0 9 8 
1 2 7 6 5 
3 4 5 0 9 
1 9 1 2 9 
7 6 8 7 4

By Swapping of Positions

As we can see in the above approach, the transpose of the matrix has to be found twice. Also, the reversal of the columns has to be found twice. Therefore, we can do some optimization to get a better solution.

In this approach, we will swap the values in the different positions. Observe the following program.

FileName: RotateMatrix2.java

public class RotateMatrix2
{

// a method for Reversing the row at the specified index in the given matrix
// @param arr -> matrix
// @param idx -> row index
private static void reverseRows(int[][] arr, int idx) 
{
int c = arr[idx].length;
for (int j = 0; j < c / 2; j++) 
{
int t = arr[idx][j];
arr[idx][j] = arr[idx][c - j - 1];
arr[idx][c - j - 1] = t;
}
}
// a method that prints all
// the rows of the given matrix 
public void printMatrix(int a[][], int r, int c)
{
for (int j = 0; j < r; j++) 
{
for (int i = 0; i < c; i++)
{
System.out.print(a[j][i] + " ");
}
System.out.println();
}
}
// rotating the matrix by 180 degree
private static void rotateMatrixBy180(int[][] arr, int r, int c) 
{
if (r % 2 != 0) {
//If r is odd, then the middle row of the matrix is reversed
reverseRows(arr, arr.length / 2);
}

// Swap the value of matrix arr[j][i] with [rows - j - 1][cols - i - 1] for the half of the size of rows.
for (int j = 0; j <= (r / 2) - 1; j++) 
{
for (int i = 0; i < c; i++) 
{
int t = arr[j][i];
arr[j][i] = arr[r - j - 1][c - i - 1];
arr[r - j - 1][c - i - 1] = t;
}
}
}
// main method
public static void main(String argvs[])
{
//creating an object of the class RotateMatrix2
RotateMatrix2 obj = new RotateMatrix2();
// input matrix
int matrix[][] = {{ 4, 6, 7, 8 },
{ 9, 3, 2, 1 },
{ 9, 0, 4, 5 },
{ 8, 0, 3, 2 }
};
// row length of the matrix          
int row = matrix.length;
// column length of the matrix
int col = matrix[0].length;
System.out.println("For the following matrix: ");
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("The rotated matrix at 180 degree is: ");
obj.rotateMatrixBy180(matrix, row, col);
obj.printMatrix(matrix, row, col);
System.out.println("\n");
// input matrix
int matrix1[][] = {{ 4, 7, 8, 6, 7 },
{ 9, 2, 1, 9, 1 },
{ 9, 0, 5, 4, 3 },
{ 5, 6, 7, 2, 1 },
{ 8, 9, 0, 5, 1 }
};
// row length of the matrix          
row = matrix1.length;
// column length of the matrix
col = matrix1[0].length;
System.out.println("For the following matrix: ");
for(int i = 0; i < row; i++)
{
for(int j = 0; j < col; j++)
{
System.out.print(matrix1[i][j] + " ");
}
System.out.println();
}
System.out.println();
System.out.println("The rotated matrix at 180 degree is: ");
obj.rotateMatrixBy180(matrix1, row, col);
obj.printMatrix(matrix1, row, col);
System.out.println("\n");
}
}

Output:

For the following matrix: 
4 6 7 8 
9 3 2 1 
9 0 4 5 
8 0 3 2 

The rotated matrix at 180 degree is: 
2 3 0 8 
5 4 0 9 
1 2 3 9 
8 7 6 4 

For the following matrix: 
4 7 8 6 7 
9 2 1 9 1 
9 0 5 4 3 
5 6 7 2 1 
8 9 0 5 1 

The rotated matrix at 180 degree is: 
1 5 0 9 8 
1 2 7 6 5 
3 4 5 0 9 
1 9 1 2 9 
7 6 8 7 4

Complexity Analysis

In the above programs, we are traversing each row and column of the matrix. It leads to the time complexity of O(R * C), where R is the row size of the input matrix and C is the column size of the input matrix.

Note that we are not using any auxiliary space to store the data; for swapping the data, we are using the same input array that leads to the space complexity of O(1).

Next TopicDangling Else Problem in Java

← prev next →