Question

我知道有一种简单的方法可以使用转置将方形矩阵旋转90度，但是我正在编写一种解决方案，好像我不知道该解决方案一样（换句话说，我想进行交换）。下面的总体思路是逐层交换。 offset代表要交换的层（从外到内）。

这是算法（请注意，它包装在class中，因为这是 Leetcode 的东西）：

class Solution:
    def rotate(self, matrix):
        for start in range(len(matrix)//2):
            end = len(matrix) - start - 1

            # swap all 4 coordinates:
            for offset in range(start, end): 
                # swap top_left over top_right
                temp, matrix[start+offset][end] = matrix[start+offset][end], matrix[start][start+offset]

                # swap top_right -> bottom_right 
                temp, matrix[end][end-offset] = matrix[end][end-offset], temp

                # swap bottom_right -> bottom_left
                temp, matrix[end-offset][start] = matrix[end-offset][start], temp

                # swap bottom_left -> top_left 
                matrix[start][start+offset] = temp

这适用于一些使用较小矩阵的手动测试，以及Leetcode提交中较小的输入测试用例。但是，它在以下输入上失败：

[[ 2,  29,  20,  26,  16,  28],
 [12,  27,   9,  25,  13,  21],
 [32,  33,  32,   2,  28,  14],
 [13,  14,  32,  27,  22,  26],
 [33,   1,  20,   7,  21,   7],
 [ 4,  24,   1,   6,  32,  34]]

预期输出：

[[ 4,  33,  13,  32,  12,   2],
 [24,   1,  14,  33,  27,  29],
 [ 1,  20,  32,  32,   9,  20],
 [ 6,   7,  27,   2,  25,  26],
 [32,  21,  22,  28,  13,  16],
 [34,   7,  26,  14,  21,  28]]

我的输出：

[[ 4,  33,  13,  32,  12,   2],
 [24,   1,   7,  33,  27,  29],
 [ 1,  20,  32,   2,  14,  20],
 [ 6,  28,  32,  27,  25,  26],
 [32,  21,  22,   9,  13,  16],
 [34,   7,  26,  14,  21,  28]]

这个矩阵足够大，以至于像我对较小的输入案例进行调试一样，手工遍历该算法变得很乏味。我的实现中的错误在哪里？

Answer 1

您的offset是 off ，请尝试

for offset in range(0, end-start):

Answer 2

为了进行旋转，输入矩阵的第i行和第j列的值应等于输出矩阵的第j行第i列（转置）和（next步骤）的列应颠倒。如果我是我，我将定义一个空矩阵（例如TRANSPOSE，其大小与输入矩阵相同），并为循环定义2个（i在len（matrix）范围内，j在len（matrix）范围内。循环我会写

TRANSPOSE[i][j] = matrix[j][i]

现在我有了反转列所需的矩阵。现在我们需要反转列以获得所需的内容，因此我将使用相同的变量和范围定义另一个for循环，并且需要一个具有相同大小的空矩阵，或者我们可以再次使用输入矩阵，让我们使用输入矩阵在这种情况下。

matrix[i][j] = TRANSPOSE[i][len(matrix) - j - 1]

并返回matrix

Answer 3

您的（随机）测试数据难以跟踪和调试。最好使用可读集。

似乎执行过程也会进行过多的交换。

记住单元格值，以循环方式移动数据单元格，检索已记住的值就足够了。

这是旋转的简单实现，其中垫由序列号填充：

n = 5
nm = n - 1
mat = []
for i in range(n):
    a = [x for x in range(n*i, n*i+n)]
    mat.append(a)

for i in range(n):
   (print(mat[i]))

for row in range((n + 1)//2):
    for col in range(n//2):
        t = mat[row] [col]
        mat[row][col] = mat[nm-col][row]
        mat[nm-col][row] = mat[nm-row][nm-col]
        mat[nm-row][nm - col] = mat[col][nm-row]
        mat[col][nm-row] = t    

print("")
for i in range(n):
   (print(mat[i]))

[0, 1, 2, 3, 4]
[5, 6, 7, 8, 9]
[10, 11, 12, 13, 14]
[15, 16, 17, 18, 19]
[20, 21, 22, 23, 24]

[20, 15, 10, 5, 0]
[21, 16, 11, 6, 1]
[22, 17, 12, 7, 2]
[23, 18, 13, 8, 3]
[24, 19, 14, 9, 4]

在我的旋转矩阵代码中找不到错误

3 个答案: