[LeetCode 48] 旋转图像

题目描述

给定一个 n × n 的二维矩阵表示一个图像。

将图像顺时针旋转 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]
]

题目分析

做矩阵旋转的题其实很好想，我们假设是一个22的数组，那么旋转一下不就是
（0，0）——>（1，0），
（1，0）——>（1，1），
（1，1）——>（0，1），
（0，1）——>（0，0）。
这个没什么难想的。那么扩展一下到33的矩阵呢，就是先四个角旋转，再将中间的进行旋转呗。
那么下面难一点55呢，也是先将四角旋转，接下来是（1，0）再下来是（2，0）……（3，0）因为（5，0）一开始就已经旋转过了。接着又开始内层的33旋转。
剩下的就翻译成代码就行啦。

源码

class Solution {
public void rotate(int[][] matrix) {
    if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
        return;
    }

    int col = matrix[0].length-1;
    int row = matrix.length-1;

    int CurCol = col;
    int CurRow = row;

    for (int r = 0; r < CurRow ; r++) {
        for (int c = r; c < CurCol; c++) {
            int x1 = r;
            int y1 = c;

            int x2 = c;
            int y2 = col - r;

            int x3 = row - r;
            int y3 = col - c;

            int x4 = row - c;
            int y4 = r;

            swap(matrix, x1, y1, x2, y2);
            swap(matrix, x1, y1, x3, y3);
            swap(matrix, x1, y1, x4, y4);
        }
        CurRow--;
        CurCol--;
    }
}

public void swap(int[][] matrix, int x1, int y1, int x2, int y2) {
    int temp = matrix[x1][y1];
    matrix[x1][y1] = matrix[x2][y2];
    matrix[x2][y2] = temp;
}

}

难点

对于我来说，难点主要是三个。
第一个就是矩阵的行列数，或者是坐标是数组个数减一，往往做的时候就会忘记了。
第二个是把每四个点给表示出来，这个也太绕了吧，不得设N*N的矩阵来计算。
第三个是交换的时候，因为在底层时（x1，y1）和（x2，y2）已经交换过了地址了，事实上只要讲（x1，y1）的地址不断与其他三个角交换就行。

改进

上面的思路确实很清晰，那么有没有更巧妙一点的方法，或者换个算法来解决这个问题呢？有一个方法，把矩阵的每个地址看作是一个坐标轴上的点，与旋转后的点相比会发现，不过就是把矩阵从后向前重新填了一下吧！

改进代码

class Solution {
public void rotate(int[][] matrix) {
    int[][] flag = new int[matrix.length][matrix.length];
  //创建一个数组进行复制，原因就是它的方法是void 不然就可以直接填进去返回这个新数据就完事了
    for (int i=0; i<matrix.length; i++) {
        for (int j=0; j<matrix.length; j++) {
            flag[i][j] = matrix[i][j];
        }
    }
    //复制的原因就是直接用等号了原先matrix的地址也会改变，这样再重新填入的时候就比较麻烦了

    for (int i=0; i<matrix.length; i++) {
        for (int j=0; j<matrix.length; j++) {
            matrix[j][i] = flag[matrix.length-1-i][j];
        }
    }
}
}

分析

这两个算法的时间复杂度都为O（n^2）

小结

旋转矩阵和选择图像其实是一样的道理，毕竟图像都是一个一个的像素组成的呀，只是相对矩阵比较庞大罢了。解这种题其实和动态规划的思路有那么点接近，都是先考虑状态，再想状态的转移，一步一步思考下去。

[1]https://leetcode-cn.com/problems/rotate-image/