【题目描述】

有一副由NxN矩阵表示的图像，这里每个像素用一个int表示，请编写一个算法，在不占用额外内存空间的情况下(即不使用缓存矩阵)，将图像顺时针旋转90度。

给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于500，图像元素小于等于256。

测试样例：

[[1,2,3],[4,5,6],[7,8,9]],3   返回：[[7,4,1],[8,5,2],[9,6,3]]

【思路1】时间复杂的

第一步：先将矩阵以次对角线互换 （如果是逆时针则为主对角线）

第二步：交换第i行到第n-i-1行

public int[][] transformImage(int[][] mat, int n) {
	if (mat == null) {
		return null;
	}
	int temp = 0;
	for (int i = 0; i < n - 1; i++) {
		for (int j = 0; j < n - i - 1; j++) {
			temp = mat[i][j];
			mat[i][j] = mat[n - j - 1][n - i - 1];
			mat[n - j - 1][n - i - 1] = temp;
		}
	}
	for (int i = 0; i < (n / 2); ++i) {
		for (int j = 0; j < n; ++j) {
			temp = mat[i][j];
			mat[i][j] = mat[n - i - 1][j];
			mat[n - i - 1][j] = temp;
		}
	}
	return mat;
}

【思路2】

（1）当n=1时，不旋转。

（2）当n=2时，旋转后变为，即a[0][0]=a[1][0]，a[1][0] = a[1][1]，a[1][1] = a[0][1]，a[0][1] = a[0][0]

总结规律为：a[i][j] = a[n-1-j][i]

（3）当n=3时，旋转后变为，符合上述规律

（4）当n=4，5......符合上述规律

不考虑空间复杂度，只需要再构建一个二维数组b[n][n]，利用公式b[i][j] = a[n-1-j][i]，代码如下：

public void rotate(int[][] matrix) {
    int n = matrix.length;
    int[][] m = new int[n][n];
    for(int row=0;row<n;row++){
        for(int col=0;col<n;col++){
            m[row][col] = matrix[n-1-col][row];
        }
    }
    //再赋值回matrix，注意java是形参是引用传递
    for(int row=0;row<n;row++){
        for(int col=0;col<n;col++){
            matrix[row][col] = m[row][col];
        }
    }
}

考虑到空间复杂度：

把焦点放在一个元素的旋转上，可以看出要在原数组中旋转，在不丢失数据的情况下，每个值的要旋转会“波及”4个数，以1为例波及到了1,3,7,9，每个数旋转要不丢失数据就要考虑如何让这个4个数都得以保留，

前边总结了规律a[i][j] = a[n-1-j][i]，分析每组被波及的数，我们可以得出这里波及的4了数其实就是

a[i][j]

a[n-1-j][i]

a[n-1-i][n-1-j]

a[n-1-(n-1-j)][n-1-i]=a[j][n-1-i]

所以这里需要引入一个临时变量temp就可以解决这4个数的顺时针交换，如

n=1时，不需旋转。

n=2时，只需要完成1（a[0][0]）的旋转，就完成了整个数组的旋转。

n=3时，需要完成1,2（a[0][0],a[0][1]）的旋转，就完成了整个数组的旋转。

n=4时，需要完成1,2,3,6（a[0][0至3]，a[1][1]）的旋转

n=5时，需要完成(a[0][0至4]，a[1][1至2])

大致可以总结出这么一个规律，对于要旋转的数a[i][j]满足：

i<n/2且i<=j<n-1-i

public int[][] transformImage(int[][] mat, int n) {
    for (int layer = 0; layer < n / 2; ++layer) {
        int first = layer;
        int last = n - 1 - layer;
        for (int i = first; i < last; ++i) {
            int offset = i - first;
            // 存储上边
            int top = mat[first][i];
            // 左到上
            mat[first][i] = mat[last - offset][first];
            // 下到做
            mat[last - offset][first] = mat[last][last - offset];
            // 右到下
            mat[last][last - offset] = mat[i][last];
            // 上到右
            mat[i][last] = top;
        }
    }
    return mat;
}