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]
]

分析：
题目意思很简单，很容易理解。若是题目不给限制，那么很好作，新建一个一样大小的二维数组，将每个元素按照新的位置要求存入便可。但题目要求在原地完成，不建立新数组，固然也不能新建其余的存储元素的数据结构。这样一会儿把题目提升了一大截。
既然是原地旋转，那咱们就须要看一下每个元素是如何移动的。
咱们看示例1中给出的 3 3 的二维数组。
左上角的元素1，旋转以后再右上角，那么脚标的变化就是
[0][0] --> [0][2]
其余的元素以此类推的旋转：
[0][2] --> [2][2]
[2][2] --> [2][0]
[2][0] --> [0][0]
[0][1] --> [1][1]
[1][1] --> [2][1]
[2][1] --> [1][0]
[1][0] --> [0][1]
请在这个过程当中找到换位的规律。
再看示例2中的 4 4 的二维数组。
[0][0] --> [0][3]
[0][3] --> [3][3]
[3][3] --> [3][0]
[3][0] --> [0][0]
[0][1] --> [1][3]
[0][2] --> [2][3]
[1][1] --> [1][2]
使用概括法，咱们能够发现规律：

[x][y] --> [y][n - 1 - x]

这样，咱们获得任何一个元素，只须要根据它的两个脚标就能够得出它要去到哪一个位置。
如今要选择移动的方法，可使用临时变量temp来做为暂存变量，帮助换位置，但这样的速度较慢。建议使用异或的方法。
a = a ^ b
b = a ^ b
a = a ^ b
这种方法效率高，速度快。
好的，找到目的地的脚标后，准备好移动元素了。
那么如何移动？是用双重for循环，按照0到n-1的顺序让全部元素交换吗？这样是不行的。若是按照顺序那么[0][0]将会存放到[0][n-1]，那么[0][n-1]本来的值怎么办？当按照顺序遍历到[0][n-1]时，去哪里获得其本来的值。因此按照顺序遍历移位是不行的。
那么怎么办？仔细观察能够发现，一个矩阵里面，旋转会让4个元素互相到达对方的位置，能够把对应的4个元素归为一组。好比：
[0][0] --> [0][3]
[0][3] --> [3][3]
[3][3] --> [3][0]
[3][0] --> [0][0]
这是矩阵四个角的4个元素归为了一组，旋转图像就是它们的位置互换。咱们能够利用这个规律，让矩阵一次把一组4个元素的位置所有换完，而后再进行下一组4个元素。
咱们可使用两两换位的方法完成，让一个元素连续换位置3次，就可让4个元素都到达各自须要的地方。按照这个思路，那么不能按照顺时针方向的元素去交换，由于让一个元素按照顺时针方向交换位置3次，那么全部的元素都想逆时针方向旋转了90度，这不符合题意。只能按照逆时针方向交换位置3次。
那么顺时针方向脚标变化的规律是：

[x][y] --> [y][n - 1 - x]

能够获得逆时针方向脚标变化的规律是：

[x][y] --> [n - 1 - y][x]

那么能够获得变化的代码

for (int j = 0; j < 3; j++) {
                x2 = n - 1 - y1;
                y2 = x1;

                matrix[x1][y1] = matrix[x1][y1] ^ matrix[x2][y2];
                matrix[x2][y2] = matrix[x1][y1] ^ matrix[x2][y2];
                matrix[x1][y1] = matrix[x1][y1] ^ matrix[x2][y2];

                x1 = x2;
                y1 = y2;
        }

上面的for循环是固定进行3次，每一次两两换位置以后，用新位置的脚标继续进行换位置。这样一组4个元素就完成了旋转。
好的，完成上面的代码，就说明工做完成了一半了。
接下来要考虑的就是，如何找到4个元素为一组的每一组。
继续观察：
3 3 的矩阵，有9个元素，须要旋转2组元素。
4 4 的矩阵，有16个元素，须要旋转4组元素。
能够总结规律旋转的次数：

int count = n * n / 4;

最后，比较困难的部分就是如何定位到矩阵中的每个组须要旋转的元素。
3 3 的矩阵，须要旋转2组元素，须要定位到 [0][0], [0][1]
4 4 的矩阵，须要旋转4组元素，须要定位到 [0][0], [0][1], [0][2], [1][1]
5 * 5 的矩阵，须要旋转6组元素，须要定位到 [0][0], [0][1], [0][2], [0][3], [1][1], [1][2]
...
这一步比较困难，好在笔者在思考良久才寻到的法子。过程不解释了，你们从下面完整的解答代码中看吧。
如下是java解答：

public void rotate(int[][] matrix) {
    int n = matrix.length;

    if (n <= 1) {
        return;
    }

    //旋转次数
    int count = n * n / 4;

    int x = 0;
    int y = 0;
    int z = 0;

    int x1, y1, x2, y2;

    for (int i = 0; i < count; i++) {
        if (z >= (n - 1) - 2 * x) {
            x += 1;
            z = 0;
        }
        y = z + x;
        z += 1;

        x1 = x;
        y1 = y;

        for (int j = 0; j < 3; j++) {
            x2 = n - 1 - y1;
            y2 = x1;

            matrix[x1][y1] = matrix[x1][y1] ^ matrix[x2][y2];
            matrix[x2][y2] = matrix[x1][y1] ^ matrix[x2][y2];
            matrix[x1][y1] = matrix[x1][y1] ^ matrix[x2][y2];

            x1 = x2;
            y1 = y2;
        }
    }
}