## Related Articles

• Write an Interview Experience
• Matrix Data Structure

# Rotate a Matrix by 180 degree

• Difficulty Level : Medium
• Last Updated : 19 Aug, 2022

Given a square matrix, the task is that we turn it by 180 degrees in an 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 degrees 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 degrees then we will have to print the given matrix in a 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``?>`

## Javascript

 ``

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 a matrix.
2- Reverse columns of the transpose.
3- Find transpose of a 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`

## Python3

 `# Python3 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

 ``

## Javascript

 ``

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, the 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.

## C++

 `#include ``using` `namespace` `std;` `/**`` ``* Reverse Row at specified index in the matrix`` ``* @param data matrix`` ``* @param index row index`` ``*/``void` `reverseRow(vector>& data,``                ``int` `index)``{``    ``int` `cols = data[index].size();``    ``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`` ``*/``void` `printMatrix(vector>& data)``{``    ``for``(``int` `i = 0; i < data.size(); i++)``    ``{``        ``for``(``int` `j = 0; j < data[i].size(); j++)``        ``{``            ``cout << data[i][j] << ``" "``;``        ``}``        ``cout << endl;``    ``}``}` `/**`` ``* Rotate Matrix by 180 degrees`` ``* @param data matrix`` ``*/``void` `rotateMatrix180(vector>& data)``{``    ``int` `rows = data.size();``    ``int` `cols = data[0].size();` `    ``if` `(rows % 2 != 0)``    ``{``        ` `        ``// If N is odd reverse the middle``        ``// row in the matrix``        ``reverseRow(data, data.size() / 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;``        ``}``    ``}``}` `// Driver code   ``int` `main()``{``    ``vector> 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);` `    ``return` `0;``}` `// This code is contributed by divyeshrabadiya07`

## 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);``    ``}``}`

## Python3

 `# Reverse Row at specified index in the matrix``def` `reverseRow(data, index):``    ` `    ``cols ``=` `len``(data[index])``    ``for` `i ``in` `range``(cols ``/``/` `2``):``        ``temp ``=` `data[index][i]``        ``data[index][i] ``=` `data[index][cols ``-` `i ``-` `1``]``        ``data[index][cols ``-` `i ``-` `1``] ``=` `temp``    ` `    ``return` `data` `# Print Matrix data``def` `printMatrix(data):``    ` `    ``for` `i ``in` `range``(``len``(data)):``        ``for` `j ``in` `range``(``len``(data[``0``])):``            ``print``(data[i][j], end ``=` `' '``)``        ` `        ``print``()` `# Rotate Matrix by 180 degrees``def` `rotateMatrix(data):``    ` `    ``rows ``=` `len``(data)``    ``cols ``=` `len``(data[``0``])``    ` `    ``if` `(rows ``%` `2``):``        ` `        ``# If N is odd reverse the middle``        ``# row in the matrix``        ``data ``=` `reverseRow(data, ``len``(data) ``/``/` `2``)``        ` `        ``# Swap the value of matrix [i][j] with``        ``# [rows - i - 1][cols - j - 1] for half``        ``# the rows size.``        ``for` `i ``in` `range``(rows ``/``/` `2``):``            ``for` `j ``in` `range``(cols):``                ``temp ``=` `data[i][j]``                ``data[i][j] ``=` `data[rows ``-` `i ``-` `1``][cols ``-` `j ``-` `1``]``                ``data[rows ``-` `i ``-` `1``][cols ``-` `j ``-` `1``] ``=` `temp``        ` `        ``return` `data``        ` `# Driver Code``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``data ``=` `rotateMatrix(data)` `# Print Matrix``printMatrix(data)` `# This code is contributed by rohitsingh07052`

## C#

 `using` `System;` `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.GetLength(1);``    ``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.GetLength(0); i++)``    ``{``      ``for` `(``int` `j = 0; j < data.GetLength(1); j++)``      ``{``        ``Console.Write(data[i, j] + ``" "``);``      ``}``      ``Console.WriteLine();``    ``}``  ``}` `  ``/**``     ``* Rotate Matrix by 180 degrees``     ``* @param data matrix``     ``*/``  ``private` `static` `void` `rotateMatrix180(``int``[, ] data)``  ``{``    ``int` `rows = data.GetLength(0);``    ``int` `cols = data.GetLength(1);` `    ``if` `(rows % 2 != 0)``    ``{` `      ``// If N is odd reverse the middle row in the``      ``// matrix``      ``reverseRow(data, data.GetLength(0) / 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;``      ``}``    ``}``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``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);``  ``}``}` `// This code is contributed by subhammahato348`

## Javascript

 ``

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), since no extra space has been taken.

My Personal Notes arrow_drop_up