给定一个 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;
        }
    }
}