## Related Articles

• Write an Interview Experience
• Matrix Data Structure

# Inplace rotate square matrix by 90 degrees | Set 1

• Difficulty Level : Hard
• Last Updated : 15 Sep, 2022

Given a square matrix, turn it by 90 degrees in an anti-clockwise direction without using any extra space

Examples:

Input:
Matrix:    1  2  3
4  5  6
7  8  9

Output:  3  6  9
2  5  8
1  4  7

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

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

Note: An approach that requires extra space is already discussed here.

## Inplace rotate square matrix by 90 degrees by forming cycles:

To solve the problem follow the below idea:

To solve the question without any extra space, rotate the array in form of squares, dividing the matrix into squares or cycles. For example,
A 4 X 4 matrix will have 2 cycles. The first cycle is formed by its 1st row, last column, last row, and 1st column. The second cycle is formed by the 2nd row, second-last column, second-last row, and 2nd column. The idea is for each square cycle, to swap the elements involved with the corresponding cell in the matrix in an anti-clockwise direction i.e. from top to left, left to bottom, bottom to right, and from right to top one at a time using nothing but a temporary variable to achieve this

Dry run of the above approach:

First Cycle:

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

Moving first group of four elements (elements
of 1st row, last row, 1st column and last column) of first cycle
in counter clockwise.

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

Moving next group of four elements of
first cycle in counter clockwise

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

Moving final group of four elements of
first cycle in counter clockwise

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

Second Cycle:

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

Fixing second cycle

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

Follow the given steps to solve the problem:

• There are N/2 squares or cycles in a matrix of side N. Process a square one at a time. Run a loop to traverse the matrix a cycle at a time, i.e loop from 0 to N/2 – 1, loop counter is i
• Consider elements in group of 4 in current square, rotate the 4 elements at a time. So the number of such groups in a cycle is N – 2*i.
• So run a loop in each cycle from x to N – x – 1, loop counter is y
• The elements in the current group is (x, y), (y, N-1-x), (N-1-x, N-1-y), (N-1-y, x), now rotate the these 4 elements, i.e (x, y) <- (y, N-1-x), (y, N-1-x)<- (N-1-x, N-1-y), (N-1-x, N-1-y)<- (N-1-y, x), (N-1-y, x)<- (x, y)
• Print the matrix.

Below is the implementation of the above approach:

## C++

 `// C++ program to rotate a matrix``// by 90 degrees``#include ``#define N 4``using` `namespace` `std;` `// An Inplace function to``// rotate a N x N matrix``// by 90 degrees in``// anti-clockwise direction``void` `rotateMatrix(``int` `mat[][N])``{``    ``// Consider all squares one by one``    ``for` `(``int` `x = 0; x < N / 2; x++) {``        ``// Consider elements in group``        ``// of 4 in current square``        ``for` `(``int` `y = x; y < N - x - 1; y++) {``            ``// Store current cell in``            ``// temp variable``            ``int` `temp = mat[x][y];` `            ``// Move values from right to top``            ``mat[x][y] = mat[y][N - 1 - x];` `            ``// Move values from bottom to right``            ``mat[y][N - 1 - x] = mat[N - 1 - x][N - 1 - y];` `            ``// Move values from left to bottom``            ``mat[N - 1 - x][N - 1 - y] = mat[N - 1 - y][x];` `            ``// Assign temp to left``            ``mat[N - 1 - y][x] = temp;``        ``}``    ``}``}` `// Function to print the matrix``void` `displayMatrix(``int` `mat[N][N])``{``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``cout << mat[i][j] << ``" "``;``        ``}``        ``cout << endl;``    ``}``    ``cout << endl;``}` `/* Driver code */``int` `main()``{``    ``// Test Case 1``    ``int` `mat[N][N] = { { 1, 2, 3, 4 },``                      ``{ 5, 6, 7, 8 },``                      ``{ 9, 10, 11, 12 },``                      ``{ 13, 14, 15, 16 } };` `    ``// Function call``    ``rotateMatrix(mat);` `    ``// Print rotated matrix``    ``displayMatrix(mat);` `    ``return` `0;``}`

## Java

 `// Java program to rotate a``// matrix by 90 degrees``import` `java.io.*;` `class` `GFG {``    ``// An Inplace function to``    ``// rotate a N x N matrix``    ``// by 90 degrees in``    ``// anti-clockwise direction``    ``static` `void` `rotateMatrix(``int` `N, ``int` `mat[][])``    ``{``        ``// Consider all squares one by one``        ``for` `(``int` `x = ``0``; x < N / ``2``; x++) {``            ``// Consider elements in group``            ``// of 4 in current square``            ``for` `(``int` `y = x; y < N - x - ``1``; y++) {``                ``// Store current cell in``                ``// temp variable``                ``int` `temp = mat[x][y];` `                ``// Move values from right to top``                ``mat[x][y] = mat[y][N - ``1` `- x];` `                ``// Move values from bottom to right``                ``mat[y][N - ``1` `- x]``                    ``= mat[N - ``1` `- x][N - ``1` `- y];` `                ``// Move values from left to bottom``                ``mat[N - ``1` `- x][N - ``1` `- y]``                    ``= mat[N - ``1` `- y][x];` `                ``// Assign temp to left``                ``mat[N - ``1` `- y][x] = temp;``            ``}``        ``}``    ``}` `    ``// Function to print the matrix``    ``static` `void` `displayMatrix(``int` `N, ``int` `mat[][])``    ``{``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``for` `(``int` `j = ``0``; j < N; j++)``                ``System.out.print(``" "` `+ mat[i][j]);` `            ``System.out.print(``"\n"``);``        ``}``        ``System.out.print(``"\n"``);``    ``}` `    ``/* Driver code*/``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``4``;` `        ``int` `mat[][] = { { ``1``, ``2``, ``3``, ``4` `},``                        ``{ ``5``, ``6``, ``7``, ``8` `},``                        ``{ ``9``, ``10``, ``11``, ``12` `},``                        ``{ ``13``, ``14``, ``15``, ``16` `} };` `        ``// Function call``        ``rotateMatrix(N, mat);` `        ``// Print rotated matrix``        ``displayMatrix(N, mat);``    ``}``}` `// This code is contributed by Prakriti Gupta`

## Python3

 `# Python3 program to rotate a matrix by 90 degrees``N ``=` `4` `# An Inplace function to rotate``# N x N matrix by 90 degrees in``# anti-clockwise direction`  `def` `rotateMatrix(mat):` `    ``# Consider all squares one by one``    ``for` `x ``in` `range``(``0``, ``int``(N ``/` `2``)):` `        ``# Consider elements in group``        ``# of 4 in current square``        ``for` `y ``in` `range``(x, N``-``x``-``1``):` `            ``# store current cell in temp variable``            ``temp ``=` `mat[x][y]` `            ``# move values from right to top``            ``mat[x][y] ``=` `mat[y][N``-``1``-``x]` `            ``# move values from bottom to right``            ``mat[y][N``-``1``-``x] ``=` `mat[N``-``1``-``x][N``-``1``-``y]` `            ``# move values from left to bottom``            ``mat[N``-``1``-``x][N``-``1``-``y] ``=` `mat[N``-``1``-``y][x]` `            ``# assign temp to left``            ``mat[N``-``1``-``y][x] ``=` `temp`  `# Function to print the matrix``def` `displayMatrix(mat):` `    ``for` `i ``in` `range``(``0``, N):` `        ``for` `j ``in` `range``(``0``, N):` `            ``print``(mat[i][j], end``=``' '``)``        ``print``("")`  `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``mat ``=` `[[``0` `for` `x ``in` `range``(N)] ``for` `y ``in` `range``(N)]` `    ``mat ``=` `[[``1``, ``2``, ``3``, ``4``],``           ``[``5``, ``6``, ``7``, ``8``],``           ``[``9``, ``10``, ``11``, ``12``],``           ``[``13``, ``14``, ``15``, ``16``]]` `    ``# Function call``    ``rotateMatrix(mat)` `    ``# Print rotated matrix``    ``displayMatrix(mat)`  `# This code is contributed by saloni1297`

## C#

 `// C# program to rotate a``// matrix by 90 degrees``using` `System;` `class` `GFG {``    ``// An Inplace function to``    ``// rotate a N x N matrix``    ``// by 90 degrees in anti-``    ``// clockwise direction``    ``static` `void` `rotateMatrix(``int` `N, ``int``[, ] mat)``    ``{``        ``// Consider all``        ``// squares one by one``        ``for` `(``int` `x = 0; x < N / 2; x++) {``            ``// Consider elements``            ``// in group of 4 in``            ``// current square``            ``for` `(``int` `y = x; y < N - x - 1; y++) {``                ``// store current cell``                ``// in temp variable``                ``int` `temp = mat[x, y];` `                ``// move values from``                ``// right to top``                ``mat[x, y] = mat[y, N - 1 - x];` `                ``// move values from``                ``// bottom to right``                ``mat[y, N - 1 - x]``                    ``= mat[N - 1 - x, N - 1 - y];` `                ``// move values from``                ``// left to bottom``                ``mat[N - 1 - x, N - 1 - y]``                    ``= mat[N - 1 - y, x];` `                ``// assign temp to left``                ``mat[N - 1 - y, x] = temp;``            ``}``        ``}``    ``}` `    ``// Function to print the matrix``    ``static` `void` `displayMatrix(``int` `N, ``int``[, ] mat)``    ``{``        ``for` `(``int` `i = 0; i < N; i++) {``            ``for` `(``int` `j = 0; j < N; j++)``                ``Console.Write(``" "` `+ mat[i, j]);``            ``Console.WriteLine();``        ``}``        ``Console.WriteLine();``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``int` `N = 4;` `        ``int``[, ] mat = { { 1, 2, 3, 4 },``                        ``{ 5, 6, 7, 8 },``                        ``{ 9, 10, 11, 12 },``                        ``{ 13, 14, 15, 16 } };` `        ``// Function call``        ``rotateMatrix(N, mat);` `        ``// Print rotated matrix``        ``displayMatrix(N, mat);``    ``}``}` `// This code is contributed by ajit`

## PHP

 ``

## Javascript

 ``

Output

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

```

Time Complexity: O(N2), where n is the side of the array. A single traversal of the matrix is needed.
Auxiliary Space: O(1). As a constant space is needed

## Inplace rotate square matrix by 90 degrees by transposing and reversing the matrix:

Follow the given steps to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program to rotate a matrix``// by 90 degrees``#include ``using` `namespace` `std;``#define N 4` `// An Inplace function to``// rotate a N x N matrix``// by 90 degrees in``// anti-clockwise direction``void` `rotateMatrix(``int` `mat[][N])``{ ``// REVERSE every row``    ``for` `(``int` `i = 0; i < N; i++)``        ``reverse(mat[i], mat[i] + N);` `    ``// Performing Transpose``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = i; j < N; j++)``            ``swap(mat[i][j], mat[j][i]);``    ``}``}` `// Function to print the matrix``void` `displayMatrix(``int` `mat[N][N])``{``    ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``            ``cout << mat[i][j] << ``" "``;``        ``}``        ``cout << endl;``    ``}``    ``cout << endl;``}` `/* Driver code */``int` `main()``{``    ``int` `mat[N][N] = { { 1, 2, 3, 4 },``                      ``{ 5, 6, 7, 8 },``                      ``{ 9, 10, 11, 12 },``                      ``{ 13, 14, 15, 16 } };` `    ``// Function call``    ``rotateMatrix(mat);` `    ``// Print rotated matrix``    ``displayMatrix(mat);` `    ``return` `0;``}`

## Java

 `// Java program to rotate a``// matrix by 90 degrees``import` `java.io.*;` `class` `GFG {` `    ``// Function to reverse``    ``// the given 2D arr[][]``    ``static` `void` `Reverse(``int` `i, ``int` `mat[][], ``int` `N)``    ``{``        ``// Initialise start and end index``        ``int` `start = ``0``;``        ``int` `end = N - ``1``;` `        ``// Till start < end, swap the element``        ``// at start and end index``        ``while` `(start < end) {` `            ``// Swap the element``            ``int` `temp = mat[i][start];``            ``mat[i][start] = mat[i][end];``            ``mat[i][end] = temp;` `            ``// Increment start and decrement``            ``// end for next pair of swapping``            ``start++;``            ``end--;``        ``}``    ``}` `    ``// An Inplace function to``    ``// rotate a N x N matrix``    ``// by 90 degrees in``    ``// anti-clockwise direction` `    ``static` `void` `rotateMatrix(``int` `N, ``int` `mat[][])``    ``{ ``// REVERSE every row``        ``for` `(``int` `i = ``0``; i < N; i++)``            ``Reverse(i, mat, N);` `        ``// Performing Transpose``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``for` `(``int` `j = i; j < N; j++) {``                ``int` `temp = mat[i][j];``                ``mat[i][j] = mat[j][i];``                ``mat[j][i] = temp;``            ``}``        ``}``    ``}` `    ``// Function to print the matrix``    ``static` `void` `displayMatrix(``int` `N, ``int` `mat[][])``    ``{``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``for` `(``int` `j = ``0``; j < N; j++)``                ``System.out.print(``" "` `+ mat[i][j]);` `            ``System.out.print(``"\n"``);``        ``}``        ``System.out.print(``"\n"``);``    ``}` `    ``/* Driver code*/``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``4``;` `        ``int` `mat[][] = { { ``1``, ``2``, ``3``, ``4` `},``                        ``{ ``5``, ``6``, ``7``, ``8` `},``                        ``{ ``9``, ``10``, ``11``, ``12` `},``                        ``{ ``13``, ``14``, ``15``, ``16` `} };` `        ``// Function call``        ``rotateMatrix(N, mat);` `        ``// Print rotated matrix``        ``displayMatrix(N, mat);``    ``}``}` `// This code is contributed by Aarti_Rathi`

## Python3

 `# Python program to rotate``# a matrix by 90 degrees`  `def` `rotateMatrix(mat):` `    ``# reversing the matrix``    ``for` `i ``in` `range``(``len``(mat)):``        ``mat[i].reverse()` `    ``# make transpose of the matrix``    ``for` `i ``in` `range``(``len``(mat)):``        ``for` `j ``in` `range``(i, ``len``(mat)):` `            ``# swapping mat[i][j] and mat[j][i]``            ``mat[i][j], mat[j][i] ``=` `mat[j][i], mat[i][j]`  `# Function to print the matrix``def` `displayMatrix(mat):` `    ``for` `i ``in` `range``(``0``, ``len``(mat)):``        ``for` `j ``in` `range``(``0``, ``len``(mat)):``            ``print``(mat[i][j], end``=``' '``)``        ``print``()`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``mat ``=` `[[``1``, ``2``, ``3``, ``4``],``           ``[``5``, ``6``, ``7``, ``8``],``           ``[``9``, ``10``, ``11``, ``12``],``           ``[``13``, ``14``, ``15``, ``16``]]` `    ``# Function call``    ``rotateMatrix(mat)` `    ``# Print rotated matrix``    ``displayMatrix(mat)` `# This code is contributed by shivambhagat02(CC).`

## C#

 `// C# program to rotate a``// matrix by 90 degrees``using` `System;` `class` `GFG {``    ``// Reverse each row of matrix``    ``static` `void` `reverse(``int` `N, ``int``[, ] mat)``    ``{``        ``// Traverse each row of [,]mat``        ``for` `(``int` `i = 0; i < N; i++) {` `            ``// Initialise start and end index``            ``int` `start = 0;``            ``int` `end = N - 1;` `            ``// Till start < end, swap the element``            ``// at start and end index``            ``while` `(start < end) {` `                ``// Swap the element``                ``int` `temp = mat[i, start];``                ``mat[i, start] = mat[i, end];``                ``mat[i, end] = temp;` `                ``// Increment start and decrement``                ``// end for next pair of swapping``                ``start++;``                ``end--;``            ``}``        ``}``    ``}``    ``// An Inplace function to``    ``// rotate a N x N matrix``    ``// by 90 degrees in anti-``    ``// clockwise direction``    ``static` `void` `rotateMatrix(``int` `N, ``int``[, ] mat)``    ``{``        ``reverse(N, mat);` `        ``// Performing Transpose``        ``for` `(``int` `i = 0; i < N; i++) {``            ``for` `(``int` `j = i; j < N; j++) {``                ``int` `temp = mat[i, j];``                ``mat[i, j] = mat[j, i];``                ``mat[j, i] = temp;``            ``}``        ``}``    ``}` `    ``// Function to print the matrix``    ``static` `void` `displayMatrix(``int` `N, ``int``[, ] mat)``    ``{``        ``for` `(``int` `i = 0; i < N; i++) {``            ``for` `(``int` `j = 0; j < N; j++)``                ``Console.Write(mat[i, j] + ``" "``);``            ``Console.Write(``"\n"``);``        ``}``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``int` `N = 4;` `        ``int``[, ] mat = { { 1, 2, 3, 4 },``                        ``{ 5, 6, 7, 8 },``                        ``{ 9, 10, 11, 12 },``                        ``{ 13, 14, 15, 16 } };` `        ``// Function call``        ``rotateMatrix(N, mat);` `        ``// Print rotated matrix``        ``displayMatrix(N, mat);``    ``}``}` `// This code is contributed by Aarti_Rathi`

## Javascript

 ``

Output

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

```

Time Complexity: O(N2) + O(N2)  where N is the size of the array.
Auxiliary Space: O(1). As a constant space is needed

Exercise: Turn the 2D matrix by 90 degrees in a clockwise direction without using extra space.
Rotate a matrix by 90 degrees without using any extra space | Set 2