# Rotate a Matrix by 180 degree

Given a square matrix the task is that we turn it by 180 degrees in anti-clockwise direction without using any extra space.
Examples :

```Input :  1  2  3
4  5  6
7  8  9
Output : 9 8 7
6 5 4
3 2 1

Input :  1 2 3 4
5 6 7 8
9 0 1 2
3 4 5 6
Output : 6 5 4 3
2 1 0 9
8 7 6 5
4 3 2 1
```

Method : 1 (Only prints rotated matrix)
The solution of this problem is that to rotate a matrix by 180 degree we can easily follow that step

```Matrix =  a00 a01 a02
a10 a11 a12
a20 a21 a22

when we rotate it by 90 degree
then matrix is
Matrix = a02 a12 a22
a01 a11 a21
a00 a10 a20

when we rotate it by again 90
degree then matrix is
Matrix = a22 a21 a20
a12 a11 a10
a02 a01 a00
```

From the above illustration we get that simply to rotate the matrix by 180 degree then we will have to print given matrix in reverse manner .

## C++

 `// C++ program to rotate a matrix by 180 degrees ` `#include ` `#define N 3 ` `using` `namespace` `std; ` ` `  `// Function to Rotate the matrix by 180 degree ` `void` `rotateMatrix(``int` `mat[][N]) ` `{ ` `    ``// Simply print from last cell to first cell. ` `    ``for` `(``int` `i = N - 1; i >= 0; i--) { ` `        ``for` `(``int` `j = N - 1; j >= 0; j--) ` `            ``printf``(``"%d "``, mat[i][j]); ` ` `  `        ``printf``(``"\n"``); ` `    ``} ` `} ` ` `  `// Driven code ` `int` `main() ` `{ ` `    ``int` `mat[N][N] = { ` `        ``{ 1, 2, 3 }, ` `        ``{ 4, 5, 6 }, ` `        ``{ 7, 8, 9 } ` `    ``}; ` ` `  `    ``rotateMatrix(mat); ` `    ``return` `0; ` `} `

## Java

 `// Java program to rotate a ` `// matrix by 180 degrees ` `import` `java.util.*; ` ` `  `class` `GFG { ` `    ``static` `int` `N = ``3``; ` ` `  `    ``// Function to Rotate the ` `    ``// matrix by 180 degree ` `    ``static` `void` `rotateMatrix(``int` `mat[][]) ` `    ``{ ` ` `  `        ``// Simply print from last ` `        ``// cell to first cell. ` `        ``for` `(``int` `i = N - ``1``; i >= ``0``; i--) { ` `            ``for` `(``int` `j = N - ``1``; j >= ``0``; j--) ` `                ``System.out.print(mat[i][j] + ``" "``); ` ` `  `            ``System.out.println(); ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[][] mat = { { ``1``, ``2``, ``3` `}, ` `                        ``{ ``4``, ``5``, ``6` `}, ` `                        ``{ ``7``, ``8``, ``9` `} }; ` ` `  `        ``rotateMatrix(mat); ` `    ``} ` `} ` ` `  `// This code is contributed by ChitraNayal `

## Python3

 `# Python3 program to  ` `# rotate a matrix by  ` `# 180 degrees ` `N ``=` `3``; ` ` `  `# Function to Rotate  ` `# the matrix by 180 degree ` `def` `rotateMatrix(mat): ` `     `  `    ``# Simply print from ` `    ``# last cell to first cell. ` `    ``i ``=` `N ``-` `1``;  ` `    ``while``(i >``=` `0``): ` `        ``j ``=` `N ``-` `1``; ` `        ``while``(j >``=` `0``): ` `            ``print``(mat[i][j], end ``=` `" "``); ` `            ``j ``=` `j ``-` `1``; ` `        ``print``(); ` `        ``i ``=` `i ``-` `1``; ` ` `  `# Driven code ` `mat ``=` `[[``1``, ``2``, ``3``], ` `       ``[ ``4``, ``5``, ``6` `], ` `       ``[ ``7``, ``8``, ``9` `]]; ` `rotateMatrix(mat); ` ` `  `# This code is contributed  ` `# by mits `

## C#

 `// C# program to rotate a ` `// matrix by 180 degrees ` `using` `System; ` ` `  `class` `GFG { ` `    ``static` `int` `N = 3; ` ` `  `    ``// Function to Rotate the ` `    ``// matrix by 180 degree ` `    ``static` `void` `rotateMatrix(``int``[, ] mat) ` `    ``{ ` `        ``// Simply print from last ` `        ``// cell to first cell. ` `        ``for` `(``int` `i = N - 1; i >= 0; i--) { ` `            ``for` `(``int` `j = N - 1; j >= 0; j--) ` `                ``Console.Write(mat[i, j] + ``" "``); ` ` `  `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` ` `  `    ``// Driver Code ` `    ``static` `public` `void` `Main() ` `    ``{ ` `        ``int``[, ] mat = { { 1, 2, 3 }, ` `                        ``{ 4, 5, 6 }, ` `                        ``{ 7, 8, 9 } }; ` ` `  `        ``rotateMatrix(mat); ` `    ``} ` `} ` ` `  `// This code is contributed by aj_36 `

## PHP

 `= 0; ``\$i``--)  ` `    ``{ ` `        ``for` `(``\$j` `= ``\$N` `- 1; ``\$j` `>= 0; ``\$j``--)  ` `            ``echo` `\$mat``[``\$i``][``\$j``], ``" "``; ` `         `  `    ``echo` `"\n"``; ` `    ``} ` `} ` ` `  `// Driver Code ` `\$mat` `= ``array``(``array``(1, 2, 3), ` `             ``array``(4, 5, 6), ` `             ``array``(7, 8, 9)); ` ` `  `rotateMatrix(``\$mat``); ` ` `  `// This code is contributed by ajit ` `?> `

Output :

``` 9 8 7
6 5 4
3 2 1
```

Time complexity : O(N*N)
Auxiliary Space : O(1)

Method : 2(In-place rotation)
There are four steps :
1- Find transpose of matrix.
2- Reverse columns of the transpose.
3- Find transpose of matrix.
4- Reverse columns of the transpose

```Let the given matrix be
1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16

First we find transpose.
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16

Then we reverse elements of every column.
4 8 12 16
3 7 11 15
2 6 10 14
1 5  9 13

then transpose again
4 3 2 1
8 7 6 5
12 11 10 9
16 15 14 13

Then we reverse elements of every column again
16 15 14 13
12 11 10 9
8 7 6 5
4 3 2 1
```

## C++

 `// C++ program for left rotation of matrix by 180 ` `#include ` `using` `namespace` `std; ` ` `  `#define R 4 ` `#define C 4 ` ` `  `// Function to rotate the matrix by 180 degree ` `void` `reverseColumns(``int` `arr[R][C]) ` `{ ` `    ``for` `(``int` `i = 0; i < C; i++) ` `        ``for` `(``int` `j = 0, k = C - 1; j < k; j++, k--) ` `            ``swap(arr[j][i], arr[k][i]); ` `} ` ` `  `// Function for transpose of matrix ` `void` `transpose(``int` `arr[R][C]) ` `{ ` `    ``for` `(``int` `i = 0; i < R; i++) ` `        ``for` `(``int` `j = i; j < C; j++) ` `            ``swap(arr[i][j], arr[j][i]); ` `} ` ` `  `// Function for display the matrix ` `void` `printMatrix(``int` `arr[R][C]) ` `{ ` `    ``for` `(``int` `i = 0; i < R; i++) { ` `        ``for` `(``int` `j = 0; j < C; j++) ` `            ``cout << arr[i][j] << ``" "``; ` `        ``cout << ``'\n'``; ` `    ``} ` `} ` ` `  `// Function to anticlockwise rotate matrix ` `// by 180 degree ` `void` `rotate180(``int` `arr[R][C]) ` `{ ` `    ``transpose(arr); ` `    ``reverseColumns(arr); ` `    ``transpose(arr); ` `    ``reverseColumns(arr); ` `} ` ` `  `// Driven code ` `int` `main() ` `{ ` `    ``int` `arr[R][C] = { { 1, 2, 3, 4 }, ` `                      ``{ 5, 6, 7, 8 }, ` `                      ``{ 9, 10, 11, 12 }, ` `                      ``{ 13, 14, 15, 16 } }; ` `    ``rotate180(arr); ` `    ``printMatrix(arr); ` `    ``return` `0; ` `} `

## Java

 `// Java program for left ` `// rotation of matrix by 180 ` `import` `java.util.*; ` ` `  `class` `GFG { ` `    ``static` `int` `R = ``4``, C = ``4``, t = ``0``; ` ` `  `    ``// Function to rotate the ` `    ``// matrix by 180 degree ` `    ``static` `void` `reverseColumns(``int` `arr[][]) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < C; i++) { ` `            ``for` `(``int` `j = ``0``, k = C - ``1``; j < k; j++, k--) { ` `                ``t = arr[j][i]; ` `                ``arr[j][i] = arr[k][i]; ` `                ``arr[k][i] = t; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function for transpose of matrix ` `    ``static` `void` `transpose(``int` `arr[][]) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < R; i++) { ` `            ``for` `(``int` `j = i; j < C; j++) { ` `                ``t = arr[i][j]; ` `                ``arr[i][j] = arr[j][i]; ` `                ``arr[j][i] = t; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function for display the matrix ` `    ``static` `void` `printMatrix(``int` `arr[][]) ` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < R; i++) { ` `            ``for` `(``int` `j = ``0``; j < C; j++) ` `                ``System.out.print(arr[i][j] + ``" "``); ` `            ``System.out.println(); ` `        ``} ` `    ``} ` ` `  `    ``// Function to anticlockwise ` `    ``// rotate matrix by 180 degree ` `    ``static` `void` `rotate180(``int` `arr[][]) ` `    ``{ ` `        ``transpose(arr); ` `        ``reverseColumns(arr); ` `        ``transpose(arr); ` `        ``reverseColumns(arr); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int``[][] arr = { { ``1``, ``2``, ``3``, ``4` `}, ` `                        ``{ ``5``, ``6``, ``7``, ``8` `}, ` `                        ``{ ``9``, ``10``, ``11``, ``12` `}, ` `                        ``{ ``13``, ``14``, ``15``, ``16` `} }; ` ` `  `        ``rotate180(arr); ` `        ``printMatrix(arr); ` `    ``} ` `} ` ` `  `// This code is contributed by ChitraNayal `

## C#

 `// C# program for left ` `// rotation of matrix by 180 ` `using` `System; ` ` `  `class` `GFG { ` `    ``static` `int` `R = 4, C = 4, t = 0; ` ` `  `    ``// Function to rotate the ` `    ``// matrix by 180 degree ` `    ``static` `void` `reverseColumns(``int``[, ] arr) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < C; i++) { ` `            ``for` `(``int` `j = 0, k = C - 1; ` `                 ``j < k; j++, k--) { ` `                ``t = arr[j, i]; ` `                ``arr[j, i] = arr[k, i]; ` `                ``arr[k, i] = t; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function for transpose of matrix ` `    ``static` `void` `transpose(``int``[, ] arr) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < R; i++) { ` `            ``for` `(``int` `j = i; j < C; j++) { ` `                ``t = arr[i, j]; ` `                ``arr[i, j] = arr[j, i]; ` `                ``arr[j, i] = t; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Function for display the matrix ` `    ``static` `void` `printMatrix(``int``[, ] arr) ` `    ``{ ` `        ``for` `(``int` `i = 0; i < R; i++) { ` `            ``for` `(``int` `j = 0; j < C; j++) ` `                ``Console.Write(arr[i, j] + ``" "``); ` `            ``Console.WriteLine(); ` `        ``} ` `    ``} ` ` `  `    ``// Function to anticlockwise ` `    ``// rotate matrix by 180 degree ` `    ``static` `void` `rotate180(``int``[, ] arr) ` `    ``{ ` `        ``transpose(arr); ` `        ``reverseColumns(arr); ` `        ``transpose(arr); ` `        ``reverseColumns(arr); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``static` `public` `void` `Main() ` `    ``{ ` `        ``int``[, ] arr = { { 1, 2, 3, 4 }, ` `                        ``{ 5, 6, 7, 8 }, ` `                        ``{ 9, 10, 11, 12 }, ` `                        ``{ 13, 14, 15, 16 } }; ` ` `  `        ``rotate180(arr); ` `        ``printMatrix(arr); ` `    ``} ` `} ` ` `  `// This code is contributed by ajit `

## Python 3

 `# Python 3 program for left rotation of matrix by 180 ` `  `  `R ``=` `4` `C ``=` `4` `  `  `# Function to rotate the matrix by 180 degree ` `def` `reverseColumns(arr): ` `    ``for` `i ``in` `range``(C): ` `        ``j ``=` `0` `        ``k ``=` `C``-``1` `        ``while` `j < k: ` `            ``t ``=` `arr[j][i] ` `            ``arr[j][i] ``=` `arr[k][i] ` `            ``arr[k][i] ``=` `t ` `            ``j ``+``=` `1` `            ``k ``-``=` `1` `             `  `# Function for transpose of matrix ` `def` `transpose(arr): ` `    ``for` `i ``in` `range``(R): ` `        ``for` `j ``in` `range``(i, C): ` `            ``t ``=` `arr[i][j] ` `            ``arr[i][j] ``=` `arr[j][i] ` `            ``arr[j][i] ``=` `t ` `  `  `# Function for display the matrix ` `def` `printMatrix(arr): ` `    ``for` `i ``in` `range``(R): ` `        ``for` `j ``in` `range``(C): ` `            ``print``(arr[i][j], end ``=` `" "``); ` `        ``print``(); ` `  `  `# Function to anticlockwise rotate matrix ` `# by 180 degree ` `def` `rotate180(arr): ` `    ``transpose(arr); ` `    ``reverseColumns(arr); ` `    ``transpose(arr); ` `    ``reverseColumns(arr); ` `  `  `# Driven code ` `arr ``=` `[ [ ``1``, ``2``, ``3``, ``4` `], ` `        ``[ ``5``, ``6``, ``7``, ``8` `], ` `        ``[``9``, ``10``, ``11``, ``12` `], ` `        ``[``13``, ``14``, ``15``, ``16` `] ]; ` `rotate180(arr); ` `printMatrix(arr); `

## PHP

 ` `

Output :

``` 16 15 14 13
12 11 10 9
8 7 6 5
4 3 2 1
```

Time complexity : O(R*C)
Auxiliary Space : O(1)

In the code above, transpose of the matrix has to be found twice and also, columns have to be reversed twice.
So, we can have a better solution.

Method : 3 (Position swapping)

Here, we swap the values in the respective positions.

## Java

 `public` `class` `GFG { ` `       ``/** ` `     ``* Reverse Row at specified index in the matrix ` `     ``* @param data matrix ` `     ``* @param index row index ` `     ``*/` `    ``private` `static` `void` `reverseRow(``int``[][] data, ``int` `index) { ` `        ``int` `cols = data[index].length; ` `        ``for` `(``int` `i = ``0``; i < cols / ``2``; i++) { ` `            ``int` `temp = data[index][i]; ` `            ``data[index][i] = data[index][cols - i - ``1``]; ` `            ``data[index][cols - i - ``1``] = temp; ` `        ``} ` `    ``} ` ` `  `    ``/** ` `     ``* Print Matrix data ` `     ``* @param data matrix ` `     ``*/` `    ``private` `static` `void` `printMatrix(``int``[][] data) { ` `        ``for` `(``int` `i = ``0``; i < data.length; i++) { ` `            ``for` `(``int` `j = ``0``; j < data[i].length; j++) { ` `                ``System.out.print(data[i][j] + ``" "``); ` `            ``} ` `            ``System.out.println(``""``); ` `        ``} ` `    ``} ` ` `  `    ``/** ` `     ``* Rotate Matrix by 180 degrees ` `     ``* @param data matrix ` `     ``*/` `    ``private` `static` `void` `rotateMatrix180(``int``[][] data) { ` `        ``int` `rows = data.length; ` `        ``int` `cols = data[``0``].length; ` ` `  `        ``if` `(rows % ``2` `!= ``0``) { ` `            ``//If N is odd reverse the middle row in the matrix ` `            ``reverseRow(data, data.length / ``2``); ` `        ``} ` ` `  `        ``//Swap the value of matrix [i][j] with [rows - i - 1][cols - j - 1] for half the rows size.  ` `        ``for` `(``int` `i = ``0``; i <= (rows/``2``) - ``1``; i++) { ` `            ``for` `(``int` `j = ``0``; j < cols; j++) { ` `                ``int` `temp = data[i][j]; ` `                ``data[i][j] = data[rows - i - ``1``][cols - j - ``1``]; ` `                ``data[rows - i - ``1``][cols - j - ``1``] = temp; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``public` `static` `void` `main(String[] args) { ` `        ``int``[][] data = { ` `                ``{``1``, ``2``, ``3``, ``4``, ``5``}, ` `                ``{``6``, ``7``, ``8``, ``9``, ``10``}, ` `                ``{``11``, ``12``, ``13``, ``14``, ``15``}, ` `                ``{``16``, ``17``, ``18``, ``19``, ``20``}, ` `                ``{``21``, ``22``, ``23``, ``24``, ``25``} ` `        ``}; ` ` `  `        ``//Rotate Matrix ` `        ``rotateMatrix180(data); ` ` `  `        ``//Print Matrix ` `        ``printMatrix(data); ` `    ``} ` `} `

Output :

```25 24 23 22 21
20 19 18 17 16
15 14 13 12 11
10 9 8 7 6
5 4 3 2 1
```

Time complexity : O(R*C)
Auxiliary Space : O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

5

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.