[LeetCode] 数组+旋转图像

给定一个 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.从外层到内层，每次进行4数交换，其实就是可迭代的子问题

难点是如何用坐标表示相对位置

项目我们用一个5*5的矩阵旋转做例子进行分析

n=5

1.第1轮 i=0

第1次：j=0 00->04->44->40

第2次：j=1 01->14->43->30

第3次：j=2 02->24->42->20

第4次：j=3 03->34->41->10

[i][j]->[j][n-1-i]->[n-1-i][n-1-j]->[n-1-j][i]

2.第2轮 i=1 j=1,2

3.第3轮 i=2 j=2

下面上代码：

/*执行用时 :1 ms, 在所有Java提交中击败了80.88%的用户
* 内存消耗 :35.3 MB, 在所有Java提交中击败了87.75%的用户*/
public static void rotate1(int[][] matrix) {
		int n=matrix.length;
		for(int k=0;k<n/2;k++) {
			for(int i=0;i<((n-2*k)-1);i++) {
				int tmp=matrix[k][k+i];
				matrix[k][k+i]=matrix[n-1-(k+i)][k];
				matrix[n-1-(k+i)][k]=matrix[n-1-k][n-1-(k+i)];
				matrix[n-1-k][n-1-(k+i)]=matrix[k+i][n-1-k];
				matrix[k+i][n-1-k]=tmp;
			}
		}
	}

2.每一个元素进行相同迭代[i][j]->[j][n-1-i]

一个数带动四个数旋转：[i][j]->[j][n-1-i]->[n-1-i][n-1-j]->[n-1-j][i]

我们不难验证对于二维矩阵中的每一个元素都相当于：[i][j]->[j][n-1-i]

利用一个数组存储二维矩阵所有的元素，便可以得到如下代码

由于不需要加一个temp做迭代，时间复杂度减少；但需要建立一个数组，内存占有率增加

/* 执行用时 :1 ms, 在所有Java提交中击败了80.81%的用户
* 内存消耗 :35.3 MB, 在所有Java提交中击败了85.83%的用户*/
public static void rotate2(int[][] matrix) {
	int[] re=new int[matrix.length*matrix.length];
	for (int i=0;i<matrix.length;i++) {
		for(int j=0;j<matrix.length;j++) {
			re[i*matrix.length+j]=matrix[matrix.length-1-j][i];
		}
	}
	for (int i=0;i<matrix.length;i++) {
		for (int j=0;j<matrix.length;j++) {
			matrix[i][j]=re[i*matrix.length+j];
		}
	}
}

3.实现验证

最后，我们上实现验证代码

import java.util.Set;
import java.util.HashSet;

class Solution {
	/*执行用时 :1 ms, 在所有Java提交中击败了80.88%的用户
	 * 内存消耗 :35.3 MB, 在所有Java提交中击败了87.75%的用户
	 * 外层转完里层再转，其实就是可重叠的子问题
	 * 转的时候一个数一个数的转，一个数带动四个数
	 * 难点就是如何用坐标表示出来相对位置，写坐标的时候思路一定要清晰*/
	public static void rotate1(int[][] matrix) {
		int n=matrix.length;
		for(int k=0;k<n/2;k++) {
			for(int i=0;i<((n-2*k)-1);i++) {
				int tmp=matrix[k][k+i];
				matrix[k][k+i]=matrix[n-1-(k+i)][k];
				matrix[n-1-(k+i)][k]=matrix[n-1-k][n-1-(k+i)];
				matrix[n-1-k][n-1-(k+i)]=matrix[k+i][n-1-k];
				matrix[k+i][n-1-k]=tmp;
			}
		}
	}
	
	/*
	 * 执行用时 :1 ms, 在所有Java提交中击败了80.81%的用户
	 * 内存消耗 :35.3 MB, 在所有Java提交中击败了85.83%的用户
	 * 利用一个数组存储二维矩阵所有的元素
	 * 实现旋转图像[i][j]->[j][n-1-i]
	 */
	public static void rotate2(int[][] matrix) {
		int[] re=new int[matrix.length*matrix.length];
		for (int i=0;i<matrix.length;i++) {
			for(int j=0;j<matrix.length;j++) {
				re[i*matrix.length+j]=matrix[matrix.length-1-j][i];
			}
		}
		for (int i=0;i<matrix.length;i++) {
			for (int j=0;j<matrix.length;j++) {
				matrix[i][j]=re[i*matrix.length+j];
			}
		}
	}

    public static void main(String[] args) {
    	int[][] arr1 = {  
            {5, 1, 9, 11},  
            {2, 4, 8, 10},  
            {13, 3, 6, 7},  
            {15, 14, 12, 16},  
        };
    	rotate2(arr1);
    	for(int i=0;i<arr1.length;i++) {
    		for(int j=0;j<arr1[0].length;j++) {
    			System.out.print(arr1[i][j]+" ");
    		}
    		System.out.println();
    	}
    	
    }
}