原题目

面试题 01.07. 旋转矩阵

给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。

不占用额外内存空间能否做到？

示例 1:

给定 matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

原地旋转输入矩阵，使其变为:
[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]

示例 2:

给定 matrix =
[
  [ 5, 1, 9,11],
  [ 2, 4, 8,10],
  [13, 3, 6, 7],
  [15,14,12,16]
], 
  
原地旋转输入矩阵，使其变为:
[
  [15,13, 2, 5],
  [14, 3, 4, 1],
  [12, 6, 8, 9],
  [16, 7,10,11]
]

第一遍解法

坐标变换

我没有尝试严格证明，只是感觉旋转前后的坐标肯定可以由一个数学公式进行转换。

然后举了一些例子，去尝试找到变换前后的数学公式，找到公式后再去验证2,3个其他坐标，若是正确的，就尝试使用这个公式去做题。

当边长n为4时，令m = n - 1 = 3。

找四个点，记录旋转前后的坐标值：

• (0, 0) -> (0, 3)

• (0, 1) -> (1, 3)

• (1, 0) -> (0, 2)

• (1, 1) -> (1, 2)

列出第1,2组，发现当 i 不变时, j 加 1时，转换后的 i 也会跟着 加 1，似乎值还一样，于是认为：i(*) = j

列出第1,3组，发现当 j 不变时，i 加 1时，转换后的 j 会减 1, 它们之间的距离为 m，于是认为：j(*) = m - i

带着这个假设的公式去验证，发现是对的。

当我们把第一象限的一个点(i, j)放入tmp后，需要由第三象限相应位置填充，而此时只知道i 与 j的坐标，第一象限到第三象限是一个逆时针的过程，所以需要反解上述公式，得到：

• i(*) = m - j

• j(*) = i

依次类推，第二象限至第三象限，把这里的i(*)和j( *)当做刚才的i 和 j，可以得到

• i(**) = m - j( *) = m - i

• j(**) = i( *) = m - j

依次类推：

• i(** *) = m - j(**) = j

• j(** *) = i(**) = m - i

所以代码如下：

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int mid = (matrix.size() + 1) / 2;
        int m = matrix.size() - 1;
        for (int i = 0; i < mid; i++) {
            for (int j = 0; j < matrix.size() / 2; j++) {
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[m-j][i];
                matrix[m-j][i] = matrix[m-i][m-j];
                matrix[m-i][m-j] = matrix[j][m-i];
                matrix[j][m-i] = tmp;
            }
        }
    }
};

时间复杂度: O(n^2)

空间复杂度: O(1)

后面发现可以暴力法，代码如下：

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int m = matrix.size() - 1;
        vector<vector<int>> newM = matrix;
        for (int i = 0; i < matrix.size(); i++) {
            for (int j = 0; j < matrix.size(); j++) {
                newM[j][m-i] = matrix[i][j];
            }
        }
        matrix = newM;
    }
};

网上好的解法

思路一致，不同之处用了swap函数，这样就不需要tmp了。

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        if(n == 0) { return; }
        int r = (n>>1)-1; //左上角区域的最大行下标，
        int c = (n-1)>>1; //左上角区域的最大列下标，行列下标从 0 开始。
        for(int i = r; i >= 0; --i) {
            for(int j = c; j >= 0; --j) {
                swap(matrix[i][j], matrix[j][n-i-1]);
                swap(matrix[i][j], matrix[n-i-1][n-j-1]);
                swap(matrix[i][j], matrix[n-j-1][i]);
            }
        }
    }
};

作者：Time-Limit
链接：https://leetcode-cn.com/problems/rotate-matrix-lcci/solution/c-tu-jie-yuan-di-cao-zuo-ji-bai-shuang-bai-vv-by-t/
来源：力扣（LeetCode）

时间复杂度: O(n^2)

空间复杂度: O(1)

最后的代码

跟第一次解法一致。

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int mid = (matrix.size() + 1) / 2;
        int m = matrix.size() - 1;
        for (int i = 0; i < mid; i++) {
            for (int j = 0; j < matrix.size() / 2; j++) {
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[m-j][i];
                matrix[m-j][i] = matrix[m-i][m-j];
                matrix[m-i][m-j] = matrix[j][m-i];
                matrix[j][m-i] = tmp;
            }
        }
    }
};

时间复杂度: O(n^2)

空间复杂度: O(1)

小结

• 无

面试题 01.07. 旋转矩阵

原文：https://www.cnblogs.com/phonyhao/p/14170589.html