(Leetcode) 螺旋矩阵 - Python实现

最新推荐文章于 2023-01-02 10:43:51 发布

小布归来了

最新推荐文章于 2023-01-02 10:43:51 发布

阅读量878

点赞数

CC 4.0 BY-SA版权

分类专栏： Leetcode

本文链接：https://blog.youkuaiyun.com/weixin_42077402/article/details/93615953

Leetcode 专栏收录该内容

72 篇文章

订阅专栏

本文详细解析了螺旋矩阵遍历算法的两种实现方法，一种是通过设定限制条件改变方向逐个遍历，另一种是利用方向变量处理。文章提供了具体代码示例，并对比了不同方法的优劣。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：螺旋矩阵
给定一个包含 m x n 个元素的矩阵（m 行, n 列），请按照顺时针螺旋顺序，返回矩阵中的所有元素。
示例:
输入:
[[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]]
输出: [1,2,3,6,9,8,7,4,5]

输入:
[[1, 2, 3, 4],
[5, 6, 7, 8],
[9,10,11,12]]
输出: [1,2,3,4,8,12,11,10,9,5,6,7]

---------------------------------------------------------------------------------

解法1：通过设定限制条件改变方向，来逐个遍历（超时）

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        m = len(matrix)
        if m == 0:  # matrix为空
            return []
        if m == 1: # matrix只有一个元素
            return matrix[0]
        n = len(matrix[0])
        if n == 0:  # matrix中的元素为空
            return []

        i, j = 0, 0  # 元素的下标
        count = 1  # 记录添加的元素数量
        direction = "R"  # 初始方向向右 Right
        li = []  # 添加元素的容器
        while count <= m*n:
            li.append(matrix[i][j])
            matrix[i][j] = "MARK"
            if direction == "R":
                j += 1
                # 向右的终止条件：1.j=n 碰到右壁，2.碰到之前的元素XXX
                if j == n or matrix[i][j] == "MARK":
                    i += 1
                    j -= 1
                    direction = "D" # 更改方向为向下Down
            elif direction == "D":
                i += 1
                # 向下的终止条件：1.i=m 碰到底壁，2.碰到之前的元素XXX
                if i == m or matrix[i][j] == "MARK":
                    i -= 1
                    j -= 1
                    direction = "L"  # 更改方向为向左Left
            elif direction == "L":
                j -= 1
                # 向左的终止条件：1.j=0 碰到左壁，2.碰到之前的元素XXX
                if j < 0 or matrix[i][j] == "MARK":
                    j += 1
                    i -= 1
                    direction = "U"  # 更改方向为向上Up
            elif direction == "U":
                i -= 1
                # 向上的终止条件：1.i=0 碰到上壁，2.碰到之前的元素XXX
                if i < 0 or matrix[i][j] == "MARK":
                    i += 1
                    j += 1
                    direction = "R"

        return li

解法2：网友 “家养家养” 使用了 “方向变量” 来处理

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        m = len(matrix)
        if m == 0:  # matrix为空
            return []
        if m == 1: # matrix只有一个元素
            return matrix[0]
        n = len(matrix[0])
        if n == 0:  # matrix中的元素为空
            return []

        li = []
        i, j, di, dj = 0, 0, 0, 1
        for _ in range(m*n):
            li.append(matrix[i][j])
            matrix[i][j] = "MARK"
            # 再次回到 "MARK" 值时，就说明该转向了
            if matrix[(i+di) % m][(j+dj) % n] == "MARK":
                # 0 1 变 1 0, 1 0 变 0 -1, 0 -1 变 -1, 0, -1 0 变 0 1
                di, dj = dj, -di
            i += di
            j += dj
        return li

参考：

https://blog.youkuaiyun.com/qq_32424059/article/details/89035390

https://blog.youkuaiyun.com/weixin_41958153/article/details/81213618

https://blog.youkuaiyun.com/qq_32424059/article/details/89035106