# Rotate Matrix Elements

Last Updated : 30 Mar, 2023

Given a matrix, clockwise rotate elements in it.

Examples:

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

Output:
4    1    2
7    5    3
8    9    6

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

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

The idea is to use loops similar to the program for printing a matrix in spiral form. One by one rotate all rings of elements, starting from the outermost. To rotate a ring, we need to do following.

1. Move elements of top row.
2. Move elements of last column.
3. Move elements of bottom row.
4. Move elements of first column.

Repeat above steps for inner ring while there is an inner ring.

Below is the implementation of above idea. Thanks to Gaurav Ahirwar for suggesting below solution.

## C++

 `// C++ program to rotate a matrix `   `#include ` `#define R 4 ` `#define C 4 ` `using` `namespace` `std; `   `// A function to rotate a matrix mat[][] of size R x C. ` `// Initially, m = R and n = C ` `void` `rotatematrix(``int` `m, ``int` `n, ``int` `mat[R][C]) ` `{ ` `    ``int` `row = 0, col = 0; ` `    ``int` `prev, curr; `   `    ``/* ` `    ``row - Starting row index ` `    ``m - ending row index ` `    ``col - starting column index ` `    ``n - ending column index ` `    ``i - iterator ` `    ``*/` `    ``while` `(row < m && col < n) ` `    ``{ `   `        ``if` `(row + 1 == m || col + 1 == n) ` `            ``break``; `   `        ``// Store the first element of next row, this ` `        ``// element will replace first element of current ` `        ``// row ` `        ``prev = mat[row + 1][col]; `   `        ``/* Move elements of first row from the remaining rows */` `        ``for` `(``int` `i = col; i < n; i++) ` `        ``{ ` `            ``curr = mat[row][i]; ` `            ``mat[row][i] = prev; ` `            ``prev = curr; ` `        ``} ` `        ``row++; `   `        ``/* Move elements of last column from the remaining columns */` `        ``for` `(``int` `i = row; i < m; i++) ` `        ``{ ` `            ``curr = mat[i][n-1]; ` `            ``mat[i][n-1] = prev; ` `            ``prev = curr; ` `        ``} ` `        ``n--; `   `        ``/* Move elements of last row from the remaining rows */` `        ``if` `(row < m) ` `        ``{ ` `            ``for` `(``int` `i = n-1; i >= col; i--) ` `            ``{ ` `                ``curr = mat[m-1][i]; ` `                ``mat[m-1][i] = prev; ` `                ``prev = curr; ` `            ``} ` `        ``} ` `        ``m--; `   `        ``/* Move elements of first column from the remaining rows */` `        ``if` `(col < n) ` `        ``{ ` `            ``for` `(``int` `i = m-1; i >= row; i--) ` `            ``{ ` `                ``curr = mat[i][col]; ` `                ``mat[i][col] = prev; ` `                ``prev = curr; ` `            ``} ` `        ``} ` `        ``col++; ` `    ``} `   `    ``// Print rotated matrix ` `    ``for` `(``int` `i=0; i

## Java

 `// Java program to rotate a matrix` `import` `java.lang.*;` `import` `java.util.*;`   `class` `GFG` `{` `    ``static` `int` `R = ``4``;` `    ``static` `int` `C = ``4``;`   `    ``// A function to rotate a matrix ` `    ``// mat[][] of size R x C.` `    ``// Initially, m = R and n = C` `    ``static` `void` `rotatematrix(``int` `m,` `                    ``int` `n, ``int` `mat[][])` `    ``{` `        ``int` `row = ``0``, col = ``0``;` `        ``int` `prev, curr;`   `        ``/*` `        ``row - Starting row index` `        ``m - ending row index` `        ``col - starting column index` `        ``n - ending column index` `        ``i - iterator` `        ``*/` `        ``while` `(row < m && col < n)` `        ``{` `    `  `            ``if` `(row + ``1` `== m || col + ``1` `== n)` `                ``break``;` `    `  `            ``// Store the first element of next` `            ``// row, this element will replace ` `            ``// first element of current row` `            ``prev = mat[row + ``1``][col];` `    `  `            ``// Move elements of first row ` `            ``// from the remaining rows ` `            ``for` `(``int` `i = col; i < n; i++)` `            ``{` `                ``curr = mat[row][i];` `                ``mat[row][i] = prev;` `                ``prev = curr;` `            ``}` `            ``row++;` `    `  `            ``// Move elements of last column` `            ``// from the remaining columns ` `            ``for` `(``int` `i = row; i < m; i++)` `            ``{` `                ``curr = mat[i][n-``1``];` `                ``mat[i][n-``1``] = prev;` `                ``prev = curr;` `            ``}` `            ``n--;` `    `  `            ``// Move elements of last row ` `            ``// from the remaining rows ` `            ``if` `(row < m)` `            ``{` `                ``for` `(``int` `i = n-``1``; i >= col; i--)` `                ``{` `                    ``curr = mat[m-``1``][i];` `                    ``mat[m-``1``][i] = prev;` `                    ``prev = curr;` `                ``}` `            ``}` `            ``m--;` `    `  `            ``// Move elements of first column` `            ``// from the remaining rows ` `            ``if` `(col < n)` `            ``{` `                ``for` `(``int` `i = m-``1``; i >= row; i--)` `                ``{` `                    ``curr = mat[i][col];` `                    ``mat[i][col] = prev;` `                    ``prev = curr;` `                ``}` `            ``}` `            ``col++;` `        ``}`   `            ``// Print rotated matrix` `            ``for` `(``int` `i = ``0``; i < R; i++)` `            ``{` `                ``for` `(``int` `j = ``0``; j < C; j++)` `                ``System.out.print( mat[i][j] + ``" "``);` `                ``System.out.print(``"\n"``);` `            ``}` `    ``}`   `/* Driver program to test above functions */` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `    ``// Test Case 1` `    ``int` `a[][] = { {``1``, ``2``, ``3``, ``4``},` `                  ``{``5``, ``6``, ``7``, ``8``},` `                ``{``9``, ``10``, ``11``, ``12``},` `                ``{``13``, ``14``, ``15``, ``16``} };`   `    ``// Test Case 2` `    ``/* int a[][] = new int {{1, 2, 3},` `                            ``{4, 5, 6},` `                            ``{7, 8, 9}` `                        ``};*/` `    ``rotatematrix(R, C, a);` `    `  `    ``}` `}`   `// This code is contributed by Sahil_Bansall`

## Python

 `# Python program to rotate a matrix`   `# Function to rotate a matrix` `def` `rotateMatrix(mat):`   `    ``if` `not` `len``(mat):` `        ``return` `    `  `    ``"""` `        ``top : starting row index` `        ``bottom : ending row index` `        ``left : starting column index` `        ``right : ending column index` `    ``"""`   `    ``top ``=` `0` `    ``bottom ``=` `len``(mat)``-``1`   `    ``left ``=` `0` `    ``right ``=` `len``(mat[``0``])``-``1`   `    ``while` `left < right ``and` `top < bottom:`   `        ``# Store the first element of next row,` `        ``# this element will replace first element of` `        ``# current row` `        ``prev ``=` `mat[top``+``1``][left]`   `        ``# Move elements of top row one step right` `        ``for` `i ``in` `range``(left, right``+``1``):` `            ``curr ``=` `mat[top][i]` `            ``mat[top][i] ``=` `prev` `            ``prev ``=` `curr`   `        ``top ``+``=` `1`   `        ``# Move elements of rightmost column one step downwards` `        ``for` `i ``in` `range``(top, bottom``+``1``):` `            ``curr ``=` `mat[i][right]` `            ``mat[i][right] ``=` `prev` `            ``prev ``=` `curr`   `        ``right ``-``=` `1`   `        ``# Move elements of bottom row one step left` `        ``for` `i ``in` `range``(right, left``-``1``, ``-``1``):` `            ``curr ``=` `mat[bottom][i]` `            ``mat[bottom][i] ``=` `prev` `            ``prev ``=` `curr`   `        ``bottom ``-``=` `1`   `        ``# Move elements of leftmost column one step upwards` `        ``for` `i ``in` `range``(bottom, top``-``1``, ``-``1``):` `            ``curr ``=` `mat[i][left]` `            ``mat[i][left] ``=` `prev` `            ``prev ``=` `curr`   `        ``left ``+``=` `1`   `    ``return` `mat`   `# Utility Function` `def` `printMatrix(mat):` `    ``for` `row ``in` `mat:` `        ``print` `row`     `# Test case 1` `matrix ``=``[ ` `            ``[``1``,  ``2``,  ``3``,  ``4` `],` `            ``[``5``,  ``6``,  ``7``,  ``8` `],` `            ``[``9``,  ``10``, ``11``, ``12` `],` `            ``[``13``, ``14``, ``15``, ``16` `]  ` `        ``]` `# Test case 2` `"""` `matrix =[` `            ``[1, 2, 3],` `            ``[4, 5, 6],` `            ``[7, 8, 9]` `        ``]` `"""`   `matrix ``=` `rotateMatrix(matrix)` `# Print modified matrix` `printMatrix(matrix)`

## C#

 `// C# program to rotate a matrix` `using` `System;`   `class` `GFG {` `    `  `    ``static` `int` `R = 4;` `    ``static` `int` `C = 4;`   `    ``// A function to rotate a matrix ` `    ``// mat[][] of size R x C.` `    ``// Initially, m = R and n = C` `    ``static` `void` `rotatematrix(``int` `m,` `                        ``int` `n, ``int` `[,]mat)` `    ``{` `        ``int` `row = 0, col = 0;` `        ``int` `prev, curr;`   `        ``/*` `        ``row - Starting row index` `        ``m - ending row index` `        ``col - starting column index` `        ``n - ending column index` `        ``i - iterator` `        ``*/` `        ``while` `(row < m && col < n)` `        ``{` `    `  `            ``if` `(row + 1 == m || col + 1 == n)` `                ``break``;` `    `  `            ``// Store the first element of next` `            ``// row, this element will replace ` `            ``// first element of current row` `            ``prev = mat[row + 1, col];` `    `  `            ``// Move elements of first row ` `            ``// from the remaining rows ` `            ``for` `(``int` `i = col; i < n; i++)` `            ``{` `                ``curr = mat[row,i];` `                ``mat[row, i] = prev;` `                ``prev = curr;` `            ``}` `            ``row++;` `    `  `            ``// Move elements of last column` `            ``// from the remaining columns ` `            ``for` `(``int` `i = row; i < m; i++)` `            ``{` `                ``curr = mat[i,n-1];` `                ``mat[i, n-1] = prev;` `                ``prev = curr;` `            ``}` `            ``n--;` `    `  `            ``// Move elements of last row ` `            ``// from the remaining rows ` `            ``if` `(row < m)` `            ``{` `                ``for` `(``int` `i = n-1; i >= col; i--)` `                ``{` `                    ``curr = mat[m-1,i];` `                    ``mat[m-1,i] = prev;` `                    ``prev = curr;` `                ``}` `            ``}` `            ``m--;` `    `  `            ``// Move elements of first column` `            ``// from the remaining rows ` `            ``if` `(col < n)` `            ``{` `                ``for` `(``int` `i = m-1; i >= row; i--)` `                ``{` `                    ``curr = mat[i,col];` `                    ``mat[i,col] = prev;` `                    ``prev = curr;` `                ``}` `            ``}` `            ``col++;` `        ``}`   `            ``// Print rotated matrix` `            ``for` `(``int` `i = 0; i < R; i++)` `            ``{` `                ``for` `(``int` `j = 0; j < C; j++)` `                ``Console.Write( mat[i,j] + ``" "``);` `                ``Console.Write(``"\n"``);` `            ``}` `    ``}`   `    ``/* Driver program to test above functions */` `    ``public` `static` `void` `Main() ` `    ``{` `        ``// Test Case 1` `        ``int` `[,]a = { {1, 2, 3, 4},` `                    ``{5, 6, 7, 8},` `                    ``{9, 10, 11, 12},` `                    ``{13, 14, 15, 16} };` `    `  `        ``// Test Case 2` `        ``/* int a[][] = new int {{1, 2, 3},` `                                ``{4, 5, 6},` `                                ``{7, 8, 9}` `                            ``};*/` `        ``rotatematrix(R, C, a);` `        `  `    ``}` `}`   `// This code is contributed by nitin mittal.`

## PHP

 `= ``\$col``; ``\$i``--)` `            ``{` `                ``\$curr` `= ``\$mat``[``\$m` `- 1][``\$i``];` `                ``\$mat``[``\$m` `- 1][``\$i``] = ``\$prev``;` `                ``\$prev` `= ``\$curr``;` `            ``}` `        ``}` `        ``\$m``--;`   `        ``/* Move elements of first column` `           ``from the remaining rows */` `        ``if` `(``\$col` `< ``\$n``)` `        ``{` `            ``for` `(``\$i` `= ``\$m` `- 1; ` `                 ``\$i` `>= ``\$row``; ``\$i``--)` `            ``{` `                ``\$curr` `= ``\$mat``[``\$i``][``\$col``];` `                ``\$mat``[``\$i``][``\$col``] = ``\$prev``;` `                ``\$prev` `= ``\$curr``;` `            ``}` `        ``}` `        ``\$col``++;` `    ``}`   `    ``// Print rotated matrix` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$R``; ``\$i``++)` `    ``{` `        ``for` `(``\$j` `= 0; ``\$j` `< ``\$C``; ``\$j``++)` `        ``echo` `\$mat``[``\$i``][``\$j``] . ``" "``;` `        ``echo` `"\n"``;` `    ``}` `}`   `// Driver code`   `// Test Case 1` `\$a` `= ``array``(``array``(1, 2, 3, 4),` `           ``array``(5, 6, 7, 8),` `           ``array``(9, 10, 11, 12),` `           ``array``(13, 14, 15, 16));`   `// Test Case 2` `/* int \$a = array(array(1, 2, 3),` `                  ``array(4, 5, 6),` `                  ``array(7, 8, 9));` `*/` `rotatematrix(``\$R``, ``\$C``, ``\$a``);` `    ``return` `0;` `    `  `// This code is contributed` `// by ChitraNayal` `?>`

## Javascript

 ``

Output

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

Complexity Analysis:

• Time Complexity: O(m*n) where m is the number of rows & n is the number of columns.
• Auxiliary Space: O(1).

## C++

 `#include ` `#include `   `using` `namespace` `std;`   `// Function to rotate the matrix in a clockwise direction` `void` `rotateMatrix(vector> &matrix) {` `    ``int` `n = matrix.size();`   `    ``// Transpose the matrix` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = i; j < n; j++) {` `            ``swap(matrix[i][j], matrix[j][i]);` `        ``}` `    ``}`   `    ``// Reverse the columns` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = 0, k = n - 1; j < k; j++, k--) {` `            ``swap(matrix[j][i], matrix[k][i]);` `        ``}` `    ``}` `}`   `// Function to print the matrix` `void` `printMatrix(vector> &matrix) {` `    ``for` `(``int` `i = 0; i < matrix.size(); i++) {` `        ``for` `(``int` `j = 0; j < matrix[i].size(); j++) {` `            ``cout << matrix[i][j] << ``" "``;` `        ``}` `        ``cout << endl;` `    ``}` `}`   `int` `main() {` `    ``vector> matrix = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};` `    ``cout << ``"Original matrix:"` `<< endl;` `    ``printMatrix(matrix);` `    ``rotateMatrix(matrix);` `    ``cout << ``"Rotated matrix:"` `<< endl;` `    ``printMatrix(matrix);` `    ``return` `0;` `}`

## Java

 `import` `java.util.ArrayList;` `import` `java.util.List;`   `public` `class` `Main {`   `    ``// Function to rotate the matrix in a clockwise` `    ``// direction` `    ``public` `static` `void` `    ``rotateMatrix(List > matrix)` `    ``{` `        ``int` `n = matrix.size();`   `        ``// Transpose the matrix` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``for` `(``int` `j = i; j < n; j++) {` `                ``int` `temp = matrix.get(i).get(j);` `                ``matrix.get(i).set(j, matrix.get(j).get(i));` `                ``matrix.get(j).set(i, temp);` `            ``}` `        ``}`   `        ``// Reverse the columns` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``for` `(``int` `j = ``0``, k = n - ``1``; j < k; j++, k--) {` `                ``int` `temp = matrix.get(j).get(i);` `                ``matrix.get(j).set(i, matrix.get(k).get(i));` `                ``matrix.get(k).set(i, temp);` `            ``}` `        ``}` `    ``}`   `    ``// Function to print the matrix` `    ``public` `static` `void` `    ``printMatrix(List > matrix)` `    ``{` `        ``for` `(``int` `i = ``0``; i < matrix.size(); i++) {` `            ``for` `(``int` `j = ``0``; j < matrix.get(i).size(); j++) {` `                ``System.out.print(matrix.get(i).get(j)` `                                 ``+ ``" "``);` `            ``}` `            ``System.out.println();` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``List > matrix = ``new` `ArrayList<>();` `        ``matrix.add(``new` `ArrayList() {` `            ``{` `                ``add(``1``);` `                ``add(``2``);` `                ``add(``3``);` `            ``}` `        ``});` `        ``matrix.add(``new` `ArrayList() {` `            ``{` `                ``add(``4``);` `                ``add(``5``);` `                ``add(``6``);` `            ``}` `        ``});` `        ``matrix.add(``new` `ArrayList() {` `            ``{` `                ``add(``7``);` `                ``add(``8``);` `                ``add(``9``);` `            ``}` `        ``});` `        ``System.out.println(``"Original matrix:"``);` `        ``printMatrix(matrix);` `        ``rotateMatrix(matrix);` `        ``System.out.println(``"Rotated matrix:"``);` `        ``printMatrix(matrix);` `    ``}` `}`

## Python3

 `def` `rotate_matrix(matrix):` `    ``n ``=` `len``(matrix)` `    `  `    ``# Transpose the matrix` `    ``for` `i ``in` `range``(n):` `        ``for` `j ``in` `range``(i, n):` `            ``matrix[i][j], matrix[j][i] ``=` `matrix[j][i], matrix[i][j]` `    `  `    ``# Reverse the columns` `    ``for` `i ``in` `range``(n):` `        ``for` `j, k ``in` `zip``(``range``(n``/``/``2``), ``range``(n``-``1``, n``/``/``2``-``1``, ``-``1``)):` `            ``matrix[j][i], matrix[k][i] ``=` `matrix[k][i], matrix[j][i]`   `def` `print_matrix(matrix):` `    ``for` `row ``in` `matrix:` `        ``print``(``' '``.join(``str``(elem) ``for` `elem ``in` `row))`   `matrix ``=` `[[``1``, ``2``, ``3``], [``4``, ``5``, ``6``], [``7``, ``8``, ``9``]]` `print``(``"Original matrix:"``)` `print_matrix(matrix)` `rotate_matrix(matrix)` `print``(``"Rotated matrix:"``)` `print_matrix(matrix)`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `Program {` `// Function to rotate the matrix in a clockwise` `// direction` `public` `static` `void` `RotateMatrix(List> matrix) {` `int` `n = matrix.Count;` `     ``// Transpose the matrix` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = i; j < n; j++) {` `            ``int` `temp = matrix[i][j];` `            ``matrix[i][j] = matrix[j][i];` `            ``matrix[j][i] = temp;` `        ``}` `    ``}`   `    ``// Reverse the columns` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``for` `(``int` `j = 0, k = n - 1; j < k; j++, k--) {` `            ``int` `temp = matrix[j][i];` `            ``matrix[j][i] = matrix[k][i];` `            ``matrix[k][i] = temp;` `        ``}` `    ``}` `}`   `// Function to print the matrix` `public` `static` `void` `PrintMatrix(List> matrix) {` `    ``for` `(``int` `i = 0; i < matrix.Count; i++) {` `        ``for` `(``int` `j = 0; j < matrix[i].Count; j++) {` `            ``Console.Write(matrix[i][j] + ``" "``);` `        ``}` `        ``Console.WriteLine();` `    ``}` `}`   `static` `void` `Main(``string``[] args) {` `    ``List> matrix = ``new` `List>();` `    ``matrix.Add(``new` `List<``int``>() { 1, 2, 3 });` `    ``matrix.Add(``new` `List<``int``>() { 4, 5, 6 });` `    ``matrix.Add(``new` `List<``int``>() { 7, 8, 9 });`   `    ``Console.WriteLine(``"Original matrix:"``);` `    ``PrintMatrix(matrix);` `    ``RotateMatrix(matrix);` `    ``Console.WriteLine(``"Rotated matrix:"``);` `    ``PrintMatrix(matrix);` `}` `}`

## Javascript

 `function` `rotateMatrix(grid) {` `  ``const n = grid.length;`   `  ``// Transpose the matrix` `  ``for` `(let i = 0; i < n; i++) {` `    ``for` `(let j = i; j < n; j++) {` `      ``[grid[i][j], matrix[j][i]] = [grid[j][i], grid[i][j]];` `    ``}` `  ``}`   `  ``// Reverse the columns` `  ``for` `(let i = 0; i < n; i++) {` `    ``for` `(let j = 0, k = n - 1; j < k; j++, k--) {` `      ``[grid[j][i], matrix[k][i]] = [grid[k][i], matrix[j][i]];` `    ``}` `  ``}` `}`   `function` `printMatrix(matrix) {` `  ``for` `(let i = 0; i < grid.length; i++) {` `    ``let row = ``""``;` `    ``for` `(let j = 0; j < grid[i].length; j++) {` `      ``row += grid[i][j] + ``" "``;` `    ``}` `    ``console.log(row);` `  ``}` `}`   `let matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];` `console.log(``"Original matrix:"``);` `printMatrix(matrix);` `rotateMatrix(matrix);` `console.log(``"Rotated matrix:"``);` `printMatrix(matrix);`

Output

```Original matrix:
1 2 3
4 5 6
7 8 9
Rotated matrix:
3 6 9
2 5 8
1 4 7 ```

Complexity Analysis:

Time Complexity:
The time complexity of the given implementation is O(n^2), where n is the size of the matrix. This is because we need to traverse through all the elements of the matrix twice (once for transposing and once for reversing the columns). Therefore, the time complexity of this algorithm is quadratic.

Auxiliary Space:
The auxiliary space complexity of this implementation is O(1), which means that the amount of extra memory required for the algorithm is constant and does not depend on the input size. In this implementation, we are modifying the matrix in-place without using any additional data structure. Therefore, the space required for this algorithm is constant.

Previous
Next