旋转图像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：

由外向内分层，然后由首（坐标「0，0」的位置）至尾进行移位，每次变动四个数的位置。 那么对于n*n的矩阵来说，一圈为一层的话，一共可分为m=(n+1)/2层， 每次移动4个数字的话，则第k层需进行的次数为n-2*k-1，以此类推，例如：

举例1：当 n=3 时，则 m=(3+1)/2=2

              第0层    第1层
1 2 3      1 2 3  
4 5 6 => 4    6        5
7 8 9      7 8 9

针对第0层的旋转，全部就位需要旋转 3-2*0-1=2 次：

初始状态      第一次旋转     第二次旋转
1 2 3             7  2  1                    7  4  1
4    6   =>      4      6    =>            8      2  =>  结束
7 8 9             9  8  3                    9  6   3

针对第1层的旋转，全部就位需要旋转 3-2*1-1=0：

初始状态
5       =>  结束
 

举例2： 当 n=4 时，则 m=(4+1)//2=2

                    第0层         第1层     
1  2  3  4       1  2  3  4   
5  6  7  8       5        8      6  7
9  10 11 12  =>  9        12     10 11 
13 14 15 16      13 14 15 16   

针对第0层的旋转，全部就位需要旋转 4-2*0-1=3 次：

初始状态           第一次旋转          第二次旋转         第三次旋转
1  2  3  4       13 2  3  1         13 9  3  1       13 9  5  1
5        8   =>  5        8    =>   5        2   =>  14       2  => 结束
9        12      9        12        15       12      15       3    
13 14 15 16      16 14 15 4         16 14 8  4       16 12 8  4

针对第1层的旋转，全部就位需要旋转 4-2*1-1=1 次：

初始状态          第一次旋转          
6  7      =>     10  6      =>    结束
10 11            11  7         

解题代码：

void rotate(vector<vector<int>>& matrix) {
        int n=matrix.size();
        for(int i=0;i<=n/2;i++){
            for(int j=i;j<n-1-i;j++){
                int tmp=matrix[i][j]; 
                matrix[i][j]=matrix[n-j-1][i];
                matrix[n-j-1][i]=matrix[n-i-1][n-j-1];
                matrix[n-i-1][n-j-1]=matrix[j][n-i-1];
                matrix[j][n-i-1]=tmp;
            }
        }   
    }

 

解题思路2：

先替换上下的值，再替换对角的值，便能解决该题的需求
 

举例1：当 n=3 时

 原数组               上下交换             对角交换
1  2  3                  7  8  9                 7   4   1
4  5  6 =>             4  5  6  =>           8   5   2          其中i==j的位置交换后也不会改变
7  8  9                  1  2  3                 9   6   3

 

void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        for(int i = 0; i < n / 2; i++) {
            swap(matrix[i], matrix[n-1-i]);
        }
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < i; j++) {
                swap(matrix[i][j], matrix[j][i]);
            }
        }
    }

 

感谢你的浏览，希望能对你l理解有所帮助！