矩阵题解——螺旋矩阵 II【LeetCode】

59. 螺旋矩阵 II

第一个算法：基于层数和偏移量的方法

算法逻辑思路：

1. 初始化阶段：创建n×n的零矩阵，设置起始点(0,0)，计算需要循环的层数(n//2)，初始化计数器为1

2. 核心循环逻辑：通过偏移量控制每一层的边界

   • 外层循环：遍历每一层(offset从1到loop)

   • 内层四个循环：按顺时针方向填充当前层

     • 左→右：填充上边，范围[starty, n-offset)

     • 上→下：填充右边，范围[startx, n-offset)

     • 右→左：填充下边，范围(n-offset, starty]

     • 下→上：填充左边，范围(n-offset, startx]

3. 边界更新：每完成一层后，起始点向内移动(startx++, starty++)

4. 特殊处理：n为奇数时，单独填充最中心的元素

核心点：

通过偏移量动态计算边界，保持左闭右开的一致性原则

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums = [[0] * n for _ in range(n)]
        startx, starty = 0, 0               # 起始点
        loop, mid = n // 2, n // 2          # 迭代次数、n为奇数时，矩阵的中心点
        count = 1                           # 计数

        for offset in range(1, loop + 1) :      # 每循环一层偏移量加1，偏移量从1开始
            for i in range(starty, n - offset) :    # 从左至右，左闭右开
                nums[startx][i] = count
                count += 1
            for i in range(startx, n - offset) :    # 从上至下
                nums[i][n - offset] = count
                count += 1
            for i in range(n - offset, starty, -1) : # 从右至左
                nums[n - offset][i] = count
                count += 1
            for i in range(n - offset, startx, -1) : # 从下至上
                nums[i][starty] = count
                count += 1                
            startx += 1         # 更新起始点
            starty += 1

        if n % 2 != 0 :            # n为奇数时，填充中心点
            nums[mid][mid] = count 
        return nums

第二个算法：基于四边界收缩的方法

算法逻辑思路：

1. 初始化阶段：创建n×n矩阵，设置四个边界指针(top=0, bottom=n-1, left=0, right=n-1)

2. 核心循环逻辑：边界收缩策略

   • 条件：当top≤bottom且left≤right时继续

   • 顺时针填充四个方向：

     • 左→右：沿top行填充，然后top++

     • 上→下：沿right列填充，然后right--

     • 右→左：沿bottom行填充，然后bottom--

     • 下→上：沿left列填充，然后left++

3. 自动终止：当边界指针交叉时自然结束，无需特殊处理奇数情况

核心点：

通过四个边界指针的动态收缩，直观地控制填充范围

#定义四个边界

class Solution(object):
    def generateMatrix(self, n):
        if n <= 0:
            return []
        
        # 初始化 n x n 矩阵
        matrix = [[0]*n for _ in range(n)]

        # 初始化边界和起始值
        top, bottom, left, right = 0, n-1, 0, n-1
        num = 1

        while top <= bottom and left <= right:
            # 从左到右填充上边界
            for i in range(left, right + 1):
                matrix[top][i] = num
                num += 1
            top += 1

            # 从上到下填充右边界
            for i in range(top, bottom + 1):
                matrix[i][right] = num
                num += 1
            right -= 1

            # 从右到左填充下边界

            for i in range(right, left - 1, -1):
                matrix[bottom][i] = num
                num += 1
            bottom -= 1

            # 从下到上填充左边界

            for i in range(bottom, top - 1, -1):
                matrix[i][left] = num
                num += 1
            left += 1

        return matrix

时间复杂度：

两个算法都是 O(n²)

• 需要填充n×n个位置，每个位置访问一次

空间复杂度：

两个算法都是 O(1)

• 除了结果矩阵外，只使用常数个额外变量

• 注意：结果矩阵本身不计入额外空间

算法对比

特点	第一个算法	第二个算法
理解难度	较复杂，需理解偏移量概念	更直观，边界概念清晰
代码简洁性	需要特殊处理奇数情况	逻辑统一，无需特殊处理
边界控制	混合使用左闭右开和左闭右闭	统一使用闭区间
可读性	偏移量计算较抽象	边界收缩逻辑清晰