> For the complete documentation index, see [llms.txt](https://wentao-shao.gitbook.io/leetcode/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wentao-shao.gitbook.io/leetcode/matrix/48.rotate-image.md).

# 48.Rotate-Image

## 48. Rotate Image

## 题目地址

<https://leetcode.com/problems/rotate-image/>

## 题目描述

```
You are given an n x n 2D matrix representing an image.

Rotate the image by 90 degrees (clockwise).

Note:
You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

Example 1:
Given input matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

rotate the input matrix in-place such that it becomes:
[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]

Example 2:
Given input matrix =
[
  [ 5, 1, 9,11],
  [ 2, 4, 8,10],
  [13, 3, 6, 7],
  [15,14,12,16]
], 

rotate the input matrix in-place such that it becomes:
[
  [15,13, 2, 5],
  [14, 3, 4, 1],
  [12, 6, 8, 9],
  [16, 7,10,11]
]
```

## 思想

其中row为行数,col为列数

* 起始位置: `matrix[row][col]`
* 逆时针90度位置: `matrix[n - col - 1][row]`
* 逆时针180度位置: `matrix[n- row - 1][n- col - 1]`
* 逆时针270度位置: `matrix[col][n - row - 1]`

## 代码

### Approach 1: Transpose and then reverse

`matrix[j][n-1 - i] = matrix[i][j]`

```java
class Solution {
  public void rotate(int[][] matrix) {
        int n = matrix.length;
    // transpose matrix
    for (int i = 0; i < n; i++) {
      for (int j = i; j < n; j++) {
        int tmp = matrix[j][i];
        matrix[j][i] = matrix[i][j];
        matrix[i][j] = tmp;
      }
    }

    // reverse each row
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n / 2; j++) {
        int tmp = matrix[i][j];
        matrix[i][j] = matrix[i][n - j - 1];
        matrix[j][n - j - 1] = tmp;
      }
    }
  }
}
```

```java
public class Solution {
    public void rotate(int[][] matrix) {
        // 计算圈数
        int n = matrix.length, lvl = n / 2;
        for(int i = 0; i < lvl; i++){
            for(int j = i; j < n - i - 1; j++){
                // 左上和左下交换
                swap(matrix, i, j, j, n - i - 1);
                // 左上和右下交换
                swap(matrix, i, j, n - i - 1, n - j - 1);
                // 左上和右上交换
                swap(matrix, i, j, n - j - 1, i);
            }
        }
    }

    private void swap(int[][] matrix, int i1, int j1, int i2, int j2){
        int tmp = matrix[i1][j1];
        matrix[i1][j1] = matrix[i2][j2];
        matrix[i2][j2] = tmp;
    }
}
```

Approach #2 Rotate four rectangles

```java
class Solution {
  public void rotate(int[][] matrix) {
    int n = matrix.length;
    for (int i = 0; i < n / 2 + n % 2; i++) {
      for (int j = 0; j < n / 2; j++) {
        int[] tmp = new int[4];
        int row = i;
        int col = j;
        for (int k = 0; k < 4; k++) {
          tmp[k] = matrix[row][col];
          int x = row;
          row = col;
          col = n - 1 - x;
        }
        for (int k = 0; k < 4; k++) {
          matrix[row][col] = tmp[(k + 3) % 4];
          int x = row;
          row = col;
          col = n - 1 - x;
        }
      }
    }
  }
}
```

Approach #3 Rotate four rectangels in one single loop

```java
class Solution {
  public void rotate(int[][] matrix) {
    int n = matrix.length;
    for (int i = 0; i < (n + 1) / 2; i ++) {
      for (int j = 0; j < n / 2; j++) {
        int temp = matrix[n - 1 - j][i];
        matrix[n - 1 - j][i] = matrix[n - 1 - i][n - j - 1];
        matrix[n - 1 - i][n - j - 1] = matrix[j][n - 1 -i];
        matrix[j][n - 1 - i] = matrix[i][j];
        matrix[i][j] = temp;
      }
    }
  }
}
```