NO.48 旋转图像Rotate Image

目前想到两种解法：

1. 洋葱剥离旋转替换法

思路解析

由外向内分层，然后由首（坐标「0，0」的位置）至尾进行移位，每次变动四个数的位置。 那么对于n*n的矩阵来说，一圈为一层的话，一共可分为m=(n+1)//2层， 每次移动4个数字的话，则第k层需进行的次数为n-2*k-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  =>  done
7 8 9        9 8 3         9 6 3

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

初始状态
5       =>  done
当 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  => done
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      =>    done
10 11            11  7         
当 n=5 时，则 m=(5+1)//2=3

                       第0层            第1层      第2层
1  2  3  4  5     1  2  3  4  5   
6  7  8  9  10    6           10      7  8  9    
11 12 13 14 15 => 11          15      12    14     13
16 17 18 19 20    16          20      17 18 19
21 22 23 24 25    21 22 23 24 25          

每层的旋转请参考上述例子自行脑补

代码实现

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        n = len(matrix)  # 求出矩阵长度
        m = (n+1)//2     # 求出层数
        for k in range(m):
            t = n-2*k-1 # 需旋转的次数
            for i in range(t):
                # d1，行与k成正比，列与k成正比且与i成正比
                # d2，行与k成反比且与i成反比，列与k成正比
                # d3，行与k成反比，列与k成反比且与i成反比
                # d4，行与k成正比且与i成正比，列与k成反比
                temp = 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] = temp

 

2. 镜像旋转法 

思路解析

对矩阵行进行对折替换，如swap(row_0, row_n), swap(row_1, row_n-1)...直到进行到至rows/2处

然后以左上角与右小角元素为对角线进行替换

1 2 3     7 8 9     7 4 1
4 5 6  => 4 5 6  => 8 5 2
7 8 9     1 2 3     9 6 3

代码实现

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        ml = len(matrix)
        # 替换行
        start = 0
        end = ml - 1
        while start < end:
            matrix[start], matrix[end] = matrix[end], matrix[start]
            start += 1
            end -= 1
        # 依次替换单个坐标
        for i in range(ml):
            for j in range(i+1, ml) :
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]