很多人第一次看到“螺旋矩阵遍历”这个题目，第一反应是：这不就是一层一层绕圈吗？好像很简单。但真上手去写，十个里有八个会在边界条件上报错，要么数组越界，要么重复访问，要么中心点漏掉。这个题目看起来小巧，实际上非常考验对下标控制、循环不变量和状态切换的理解。我最早是在算法训练里被这道题折磨过，后来在实际项目中做图像分块和表格数据重组又遇到类似的逻辑，才彻底把它吃透。
这篇文章想做的，就是把螺旋矩阵遍历从思路到实现完整拆开，讲清楚“从边界到中心”这层控制到底怎么落地。不管你是刚接触算法的初学者，还是需要用矩阵遍历做图像处理、数据可视化的开发者，都应该能从这里拿到能直接用的代码和避坑经验。
1. 螺旋矩阵遍历到底在解决什么问题
1.1 一次“回字形走格子”的抽象
螺旋矩阵遍历，说白了就是给你一个二维数组，按照顺时针方向，从最外层开始，一圈一圈往里面走，最后把数组里每个元素恰好访问一次。如果用一个词概括，就是“回字形遍历”。
想象一下，你面前铺了一张网格纸，从左上角开始，先往右走，走到不能再走；然后往下走，走到不能再走；再往左走，回到这一行的左端；最后往上走，回到起点的下一格。这样你就绕完了一圈。接着把外面这一圈当作“已经用掉的墙”，进入里面一层继续做同样的事。
这个方法听起来很机械，但恰恰因为它机械，才适合被写成程序。程序最擅长的就是重复执行固定动作，只要你能把“一圈”这个动作定义清楚，剩下的只是循环多少次的问题。
1.2 常见应用场景：从图像到数据布局
可能有人觉得，这只是一个算法题，实际工作中用不到。我一开始也这么以为，直到后来做了几个和图像处理、表格数据相关的模块才明白，螺旋遍历是很多底层逻辑的骨架。
在图像处理中，有一种常见的操作是把图片分块后进行“由外向内”的像素读取，比如做边缘检测时优先处理最外圈的像素，再逐步向内收缩，这样可以减少无效区域的扫描。在数据可视化领域，一些热力图的渲染也会把数据矩阵按螺旋顺序重新排列，让视觉重心从中心向外扩散，或者反过来从外圈向内聚合。
另一个典型场景是行列转置、矩阵旋转相关的算法优化。很多操作本质上不是直接改值，而是改变遍历顺序。理解了螺旋遍历，后面再看“顺时针旋转90度”“逆时针旋转180度”这类题目，会轻松很多。可以说，这不是一个孤立的技巧，而是一类“按规则访问网格数据”的基础能力。
1.3 算法模型的输入输出拆解
从计算模型的角度看，螺旋遍历算法的输入是一个二维矩阵，输出一般有两种形式：一种是按螺旋顺序生成的一维数组，也叫“螺旋序”；另一种是原地修改矩阵，重新填值，比如“螺旋填充数字”。
我早期踩过的一个坑，就是把这两种玩法混在一起。判断一个算法要不要用额外数组，可以先问自己：目标是“读取”还是“写入”？读取只要一个列表存结果，写入则往往需要先创建一个同等大小的矩阵。目标不同，代码里的边界处理和初始化方式都会不一样。
2. 主流解法与核心控制思想
2.1 分层剥洋葱：一圈一圈处理
讲螺旋遍历，最直观的思路就是“分层剥洋葱”。把矩阵看成一层一层的洋葱皮，最外面是一层，往里剥一层，再往里一层，直到剥完。
每一层可以用四个边界来定义：
top：当前层的上边界行索引bottom：当前层的下边界行索引left：当前层的左边界列索引right：当前层的右边界列索引
初始时，这四个边界就是整个矩阵的边界。每遍历完一圈，top加一、bottom减一、left加一、right减一，表示这层已经被“吃掉”，下一循环处理内部区域。
这种思路好理解，写起来也不容易出错，关键在于每一圈内的四条边怎么走。我的习惯是，固定一条规则：
- 从当前左上角开始，向左走到右上角；
- 从上到下走到右下角；
- 从右到左走到左下角；
- 从下到上走回左上角的下方。
这个规则保持稳定，每一层都按同样的套路执行，代码自然清晰。
2.2 方向转向模拟：让每一步都有状态
另一种常见思路是“方向模拟”。给当前位置加一个方向状态，比如右、下、左、上，然后每一步都尝试往前走。如果发现下一个位置已经超出边界，或者已经访问过，就顺时针转向。
这种方法更接近人走路的感觉：一路走到头，遇到墙就右转。和分层法相比，它少了“一圈一圈”的结构感，但更通用。有些变体题目，比如“从矩阵中心开始逆时针输出”“按照蛇形路径遍历”，用方向模拟会更容易扩展。
方向模拟的核心是方向数组。比如：
directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]分别代表右、下、左、上。每次转向，就是让方向索引加一再对4取模，保证循环。是否要转向，则需要看下一个位置是否合法。
2.3 为什么说“边界控制”是灵魂
不管是分层法还是方向模拟，你都会发现，表面上的难点是“方向切换”，真正的难点其实是“边界控制”。四个边界的值什么时候更新、更新到什么程度、访问时要不要越界检查，只要有一个地方差了一个1，整个结果就乱了。
我见过很多人写螺旋遍历，思路完全正确，但是代码里到处都是+1、-1，调了半天还是不对。原因在于，他们没有把边界的语义定义清楚。
我个人的习惯是，把某个边界值理解为“当前有效区域的第一个索引”，或者“最后一个有效索引”。一旦定义清楚，代码里所有判断都要围绕这个定义来。比如我定义right代表当前层最后一列的有效索引，那么向右遍历时，循环条件就是col <= right，遍历完之后right -= 1。如果一会儿把这个边界当开区间，一会儿当闭区间，必然出错。
3. 从零手写螺旋遍历：代码与边界推导
3.1 分层法的Python实现
先上一版我最常用的分层法实现。假设输入的矩阵是matrix，行数是m，列数是n，返回螺旋顺序的一维列表。
def spiral_order(matrix): if not matrix or not matrix[0]: return [] m, n = len(matrix), len(matrix[0]) top, bottom = 0, m - 1 left, right = 0, n - 1 result = [] while top <= bottom and left <= right: # 向右：顶部一行，从左到右 for col in range(left, right + 1): result.append(matrix[top][col]) # 向下：右侧一列，从上到下 for row in range(top + 1, bottom + 1): result.append(matrix[row][right]) # 向左：底部一行，从右到左 if top < bottom: for col in range(right - 1, left - 1, -1): result.append(matrix[bottom][col]) # 向上：左侧一列，从下到上 if left < right: for row in range(bottom - 1, top, -1): result.append(matrix[row][left]) top += 1 bottom -= 1 left += 1 right -= 1 return result这段代码看起来不长，但每一行都有讲究。第二段向下遍历时，起始行是top + 1，因为右上角那个元素已经在向右遍历时被访问过了；向左遍历时，起始列是right - 1，因为右下角元素已经在向下遍历时被访问过了；向上遍历时，起始行是bottom - 1，因为左下角元素已经在向左遍历时被访问过了。
3.2 方向模拟法的Python实现
再看方向模拟法。这种写法需要借助一个visited矩阵，记录每个位置是否被访问过，所以额外空间会多一点。
def spiral_order_direction(matrix): if not matrix or not matrix[0]: return [] m, n = len(matrix), len(matrix[0]) visited = [[False] * n for _ in range(m)] directions = [(0, 1), (1, 0), (0, -1), (-1, 0)] direction_index = 0 row, col = 0, 0 result = [] for _ in range(m * n): result.append(matrix[row][col]) visited[row][col] = True next_row = row + directions[direction_index][0] next_col = col + directions[direction_index][1] if (next_row < 0 or next_row >= m or next_col < 0 or next_col >= n or visited[next_row][next_col]): direction_index = (direction_index + 1) % 4 next_row = row + directions[direction_index][0] next_col = col + directions[direction_index][1] row, col = next_row, next_col return result方向模拟法最需要注意的是：转向之后，下一步的坐标要重新计算，而不是在原坐标上继续。我在初学阶段犯过一个经典错误，转向时只改了方向索引，没有重新计算next_row和next_col，导致下一步还是往原来的方向走，结果死循环。
3.3 把下标算明白：防止数组越界的关键
写代码的时候，下标是最容易翻车的地方。很多初学者问：为什么向右遍历用了range(left, right + 1)，向下遍历却用range(top + 1, bottom + 1)？这得回到边界语义来看。
这里我把top、bottom、left、right都定义为“有效位置的下标”。向右遍历时，从left到right的每个列都是当前层的，所以必须包含right，写成right + 1。但是向下遍历时，右上角matrix[top][right]已经被取过了，所以行要从top + 1开始；又因为右下角matrix[bottom][right]还需要被取到，所以终点是bottom + 1。
向左遍历同理。从right - 1开始，一直走到left，这一步终点必须包含left，所以用range(right - 1, left - 1, -1)。向上遍历时，从bottom - 1开始，一直走到top + 1，因为top行左侧的matrix[top][left]已经在向右遍历时取过了。
我建议各位在纸上画一个3×3的矩阵，手动模拟每一行代码的取值过程。画完一遍，很多“为什么这里要加一”的疑问会自然消失。
3.4 矩阵规模的特殊情况处理
如果说常规方阵还能靠直觉硬写，空矩阵、单行、单列、单元素就需要特别小心了。
空矩阵：matrix是[]，或者matrix[0]是[]。代码开头如果没有not matrix or not matrix[0]的判断，后面访问len(matrix[0])就会直接报错。
单行矩阵，比如[[1, 2, 3]]。分层法在向下遍历时，top < bottom不成立，所以底部向左那一段不会执行；向上遍历也同理不会执行。这样输出结果就是[1, 2, 3]，正确。
单列矩阵，比如[[1], [2], [3]]。向右遍历后，向下遍历能取到[2, 3]；但因为left < right不成立，向上那段不会执行。结果正确。
单元素矩阵[[1]]更简单。向右遍历取到1，然后top == bottom、left == right，后面的条件分支都不会进入，最后输出[1]。
这些特殊情况在题目中经常作为边界测试用例出现，写代码时务必要保证它们都能通过。我把这些小分支称为“安全阀”，没有它们，逻辑再对也会崩。
4. 现场实录：调试螺旋遍历时的常见问题与排查
4.1 奇数尺寸矩阵的中心点丢了怎么办
我第一次写分层法时，用的矩阵是5×5，结果输出少了最中间那个数，最后一圈只绕了三边就结束了。排查半天，发现是循环条件写成了while top < bottom and left < right，而不是<=。
问题出在中心点。当矩阵边长是奇数时，剥到最后会剩下一个单独的元素，此时top == bottom且left == right。如果你用<作为循环继续的条件，这个元素会被挡在循环外面，永远不会被访问。
解决方案有两种：要么把循环条件改成while top <= bottom and left <= right，让最后一圈也能进入；要么单独在循环结束后判断一下，如果还有中心元素，就补进去。我推荐第一种，因为更通用，而且代码更简洁。
4.2 非方阵矩阵遍历顺序错位
方阵写熟了，遇到长条矩形比如3行5列，很容易在“向左遍历”那一段出错。原因还是边界收缩后，内部区域可能不再是完整的方形，甚至会出现某一行或某一列已经被“吃掉”的情况。
分层法里我专门加了两个判断：if top < bottom才执行底部向左，if left < right才执行左侧向上。这两个条件不是可有可无，而是为了防止在最后一行或最后一列上重复遍历。
举一个3行4列的例子。当外部循环执行完第一圈后，剩下的内部区域是一行两列，此时top == bottom，但left < right。如果不加top < bottom判断，底部向左遍历会把已经访问过的元素再访问一遍，结果出现重复值；如果加了判断，就只会向右遍历一次，结果正确。
4.3 方向模拟法陷入死循环
方向模拟法最常见的报错是IndexError，或者程序不报错但一直跑不完。前者通常是没做边界检查，后者则是转向逻辑有漏洞。
我排查这类问题通常分三步走：
第一步，检查边界判断。next_row和next_col是否同时满足0 <= 值 < 对应维度？只要有一个不满足，就必须转向。
第二步，检查转向后是否重新计算了下一步。部分人在这里犯懒，以为改个方向就行，实际上转向之后当前位置没变，必须重新算下一个位置，否则会原地打转。
第三步，检查访问标记。方向模拟法每一步都要把当前位置标记为True，否则它会不断走回已经访问过的格子，然后陷入“转向-前进-回到旧格-再转向”的死循环。
我把这三步写成了一张排查清单，之后每次写类似的方向模拟题，都按这个顺序检查，基本能一次性通过。
5. 复杂度、变体与扩展思路
5.1 时间与空间复杂度到底是多少
从时间复杂度的角度看，无论分层法还是方向模拟法，每个元素都只被访问一次。对于m × n的矩阵，时间复杂度都是O(m × n)，不存在更优的可能，因为你至少要看到每个元素才能输出它。
空间复杂度要分情况讨论。如果只返回结果列表，那么结果列表本身算输出，不计入额外空间；分层法除了几个整型变量外，没有额外数组，所以额外空间是O(1)。方向模拟法需要用visited数组记录访问状态，额外空间是O(m × n)，这一点在内存敏感的场景下需要留意。
如果题目要求“原地螺旋填充数字”，也就是在一个新矩阵里按螺旋顺序填值，那本质上也是O(m × n)的额外空间，因为你至少需要一个同样大小的矩阵来保存结果。有些题解声称原地，实际上只是把结果矩阵当作了输出，不算额外空间。
5.2 变体玩法：逆时针、螺旋填数、旋转矩阵
螺旋遍历算法有很多近亲。最常见的变体是逆时针螺旋，做法很简单，把方向数组的顺序换一下就行。顺时针是“右、下、左、上”，逆时针就是“下、右、上、左”或者按你的起始位置调整。
另一种常见变体是“螺旋填数”。给定一个n×n的空矩阵，从1开始按螺旋顺序填到n²。这其实是遍历算法的反操作：遍历是读，填数是写。你可以复用方向模拟法的壳子，把result.append换成matrix[row][col] = value，然后每次value += 1。
还有一类题目是旋转矩阵。虽然旋转矩阵和螺旋遍历不完全是一回事，但如果你把螺旋遍历的下标变化规律吃透了，旋转矩阵的坐标映射会变得很好理解。比如顺时针旋转90度，本质上是把每个元素从(i, j)映射到(j, n - 1 - i)，这和螺旋方向变化有很强的关联。
5.3 工程落地与面试描述的建议
在实际工程里，我不会轻易用方向模拟法，除非矩阵规模不大，且visited数组的内存开销可以接受。分层法因为额外空间是O(1)，更适合嵌入到图像处理、大数据分块这类场景里。
面试场景中，我更推荐优先讲清分层法。它的逻辑更直观，边界收缩的每一步都能用文字描述清楚。面试官追问边界条件时，你可以主动说“空矩阵、单行、单列、奇数中心点都需要单独考虑”，这会是加分项。
如果你准备用方向模拟法回答，一定要把“方向数组”和“转向后重新计算坐标”这两个点讲清楚，因为这正是容易写错的地方，也是面试官最爱追问的细节。我见过不少候选人思路对，但代码里忘了重置坐标，最后圆不回来。与其硬背，不如亲手多写几遍，形成肌肉记忆。
结尾
螺旋矩阵遍历看似是一个小题目，但它在“用循环模拟方向变化”这个层面上，非常值得反复练习。我个人在实际操作中的体会是，这类问题最忌讳的就是凭感觉改下标，哪怕只是差一个数字，整个遍历顺序就会崩掉。每次写完，我都会用几组特殊用例跑一遍：空矩阵、单行、单列、奇数方阵、非方阵，确保所有边界都稳了才放心。
最后再分享一个小技巧：如果你在面试或者考试中时间紧张，优先写分层法。它不需要额外数组，代码结构清晰，只要在循环条件上记得用<=，基本不会出大问题。方向模拟法虽然更灵活，但需要维护状态，写起来容易出错。两种方法都练熟之后，你会发现螺旋遍历类题目的核心，其实就是一个词——控制边界。
