数组刷题核心：边界条件、双指针与滑动窗口一次讲透

最近把数组专题的刷题笔记从第2篇翻到第6篇，重新过了一遍二分查找、移除元素、有序数组平方、长度最小子数组和螺旋矩阵。第一遍刷的时候我基本是跟着模板硬记，第二遍才发现，这几个题表面上是五道不同的题，骨子里其实都在讲同一件事：数组的元素在内存里是连续摆放的，所以一切操作都绕不开下标和边界。

这篇文章主要写给正在按专题刷数组题、但经常在边界条件上翻车的人。我会把这五类题的思考过程、代码写法、以及我实际踩过的坑拆开讲一遍。不是为了让你背答案，而是希望你看完之后能自己推导出边界处理方式，下次遇到变体题也不会慌。

1. 数组题翻来覆去就在考这三件事

1.1 连续内存决定了数组的“硬约束”

数组和链表最大的区别就是内存连续。连续带来两个结果：随机访问是 O(1)，但插入和删除要移动元素。后面这一点，是数组题里所有“移动、覆盖、收缩”套路的根因。

举个生活化的例子：一群人站成一排，中间有人离开，后面的人必须往前补位。数组的删除操作本质上也不是“删除”，而是“覆盖”。你让后面的人往前挪，覆盖掉离开的人的位置，顺序才算恢复。移除元素、有序数组平方、长度最小子数组这些题，最后都要回到“连续内存下的下标移动”这个物理约束上来。

理解这个之后，你会发现数组题其实不考啥高深算法，考的是你能不能把“谁覆盖谁、谁往哪走、边界在哪”这三个问题想清楚。

1.2 边界条件和循环不变量才是分水岭

数组题最常见的错不是思路错，而是边界写错。数组越界、死循环、漏掉最后一个元素，几乎都出在区间定义不清晰上。

我的习惯是：写循环之前，先明确当前区间是闭区间还是开区间，把“不变量”写在注释里。比如二分查找，先写“当前在 [left, right] 范围内查找 target”，再写代码；比如移除元素，先写“slow 之前的元素都是保留后的结果”，再动指针。这个习惯帮我省掉了大量调试时间。

一上来就写循环，边界全靠感觉，第一遍能过是运气，第二遍多半会卡。

1.3 数组题的学习顺序有讲究

我自己比较推荐的顺序是：先练单指针遍历，再练双指针，再练滑动窗口，最后练二维数组模拟。对应到这几篇笔记里，就是先二分查找，再移除元素，再有序数组平方，再滑动窗口，最后螺旋矩阵。

这个顺序不是随便排的，它是按“指针数量”和“维度”递进的：二分是单指针加区间收缩；移除元素是快慢两个同向指针；有序数组平方是两端指针；滑动窗口是右边界驱动、左边界收缩；螺旋矩阵则是把指针思维扩展到二维边界。按这个顺序刷完，你对“下标”的敏感度会明显上升。

2. 二分查找：与其背模板，不如盯住区间不变量

2.1 从左闭右闭开始推导，避免 mid 死循环

二分查找最大的误区是背模板。背下来的写法可能能过题，但你不知道为什么 left 要等于 mid + 1，为什么 right 要等于 mid - 1，稍微换个问法就懵了。

我建议用最经典的左闭右闭区间来理解：

python复制def search(nums, target):
    left, right = 0, len(nums) - 1  # [left, right] 闭区间
    while left <= right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

这里有几个必须说清楚的点：

• right = len(nums) - 1 是因为闭区间要包含最后一个下标。
• while left <= right 是因为闭区间在 left == right 时仍然有一个元素要检查。
• nums[mid] < target 时，mid 已经被查过且不是目标，目标在 mid 右边，所以 left = mid + 1。
• nums[mid] > target 时，同理 right = mid - 1。
• mid = left + (right - left) // 2 是为了防止 left + right 溢出，这是从 C++ 时代传下来的习惯，Python 不会溢出，但保留这个写法能让思维迁移到其他语言时不踩坑。

我第一次刷的时候，贪图省事写 mid = (left + right) // 2，在数组很长时其实没什么问题，但在一些语言里会有整数溢出风险。好习惯不亏。

2.2 左闭右开版本怎么改，常见错误在哪

很多资料喜欢用左闭右开区间，也就是 [left, right)。这个版本没有对错，但你必须知道它和闭区间版本的差异：

python复制def search(nums, target):
    left, right = 0, len(nums)  # [left, right) 右开区间
    while left < right:
        mid = left + (right - left) // 2
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1
        else:
            right = mid
    return -1

注意两个关键区别：

• 初始化时 right = len(nums)，因为右开区间不包含 len(nums)，所以可以直接用数组长度。
• 循环条件是 left < right，因为 left 和 right 相等时，区间已经为空，不需要再查。
• 当 nums[mid] > target 时，right = mid 而不是 mid - 1。因为右开区间本来就不包含 right，mid 已经被查过，但 mid 右边的区间范围是 [left, mid)，所以把 right 设成 mid 是对的。

最容易翻车的写法是：初始化用了左闭右开，但收缩时把 right = mid - 1；或者反过来，初始化闭区间却用 while (left < right)。区间语义和循环条件一旦不匹配，就会出现漏查或者死循环。

2.3 我踩过的坑：死循环和答案偏左偏右

二分查找的坑主要集中在“找边界位置”的变体上，比如找第一个大于等于 target 的位置。很多人在这个题上背了模板也没用，就是因为不理解 right = mid 的含义。

python复制def lower_bound(nums, target):
    left, right = 0, len(nums)  # 找第一个 >= target 的位置
    while left < right:
        mid = left + (right - left) // 2
        if nums[mid] >= target:
            right = mid
        else:
            left = mid + 1
    return left

这里 nums[mid] >= target 时，mid 可能是答案，但左边可能还有更小下标也满足条件，所以不能直接返回，也不能 right = mid - 1，否则会漏掉答案。正确做法是 right = mid，把区间收缩到 [left, mid)，继续找。

我实际调试时遇到过一种经典死循环：闭区间版本里，如果 nums[mid] < target 时我不小心写成 left = mid，那么当 left + 1 == right 时，mid 永远等于 left，区间永远无法缩小，程序就卡死了。记住一个原则：每次循环都必须让区间缩小，否则就是死循环。

提示：写二分查找之前，先问自己三个问题——初始区间包含哪些下标？循环结束条件是什么？收缩时是 mid 还是 mid ± 1？三件事全都自洽了，代码基本不会错。

3. 移除特定值：快慢指针为什么比从头删除优雅

3.1 暴力法的致命短板：每次删除都移动一批元素

这道题描述起来很简单：给定一个数组和一个值，原地移除所有等于该值的元素，返回新长度。很多人的第一反应是：找到要删的值，把后面的元素整体往前移。

逻辑上没错，但复杂度是 O(n^2)。考虑最坏情况：数组里全是目标值，每删一个元素，后面所有元素都要往左挪一位，总移动次数接近 n^2。这个复杂度在数组规模变大后是完全不能接受的。

还有一个更隐蔽的问题：用循环删除时，删除一个元素后，下标关系会变化，如果不小心跳过下一个元素，就会出现“漏删”。用暴力法如果还要保证不错，还得额外处理下标回退，代码越写越丑。

3.2 快慢指针的写法与不变量

快慢指针的思路是：不真正“删除”元素，而是把要保留的元素覆盖到前面来。

python复制def remove_element(nums, val):
    slow = 0
    for fast in range(len(nums)):
        if nums[fast] != val:
            nums[slow] = nums[fast]
            slow += 1
    return slow

这里的核心不变量是：slow 之前的元素都是“新数组”中已经保留的元素；fast 负责扫描整个原数组，把所有不等于 val 的元素找出来。

fast 走到一个不等于 val 的元素时，就把它复制到 slow 指向的位置，然后 slow 前移。fast 遇到等于 val 的元素时，什么都不做，继续往前走。整个过程只有 O(n) 次操作，空间额外开销为 O(1)。

我第一次写的时候总在想：把后面的值覆盖到前面，会不会把还没处理的数据弄丢？其实不会。因为 fast 总是大于等于 slow，fast 指向的元素在被覆盖之前，已经随着 fast 的扫描被处理过了。覆盖操作不会影响后续尚未访问的元素。

3.3 这个套路为什么能推广到很多变形题

快慢指针不只是在移除元素这一道题上有效。数组去重、移动零、压缩字符串、分割奇偶，基本都是一个思路：用 fast 找“该留下的元素”，用 slow 写“新数组的下一个位置”。

比如数组去重，如果要求保留每个元素最多两次，只需要在赋值前判断一下 slow 前面的情况；移动零，只需要把“非零元素”全部前移，后面补零。核心逻辑都是同一套。

我后来发现，这套思想迁移到链表上也很自然。链表的“删除节点”其实也是跳过引用，和数组里的覆盖思想是同一个源头。数组题刷扎实了，链表题会好上手很多。

提示：写快慢指针时，把 slow 的含义写清楚：nums[0:slow] 永远是处理完成后的有效前缀。只要这个区间不变量没被破坏，代码怎么改都不会出大问题。

4. 有序数组的平方：双指针从两端往中间合并不是偶然

4.1 为什么先平方再排序不够好

看到有序数组平方，最直接的做法是：每个元素平方，然后排序。这个做法逻辑上完全正确，代码也简单，时间复杂度是 O(n log n)，取决于排序算法的代价。

问题在于它没有利用好“原数组已经有序”这个条件。数组是排好序的，只是可能有负数，导致平方后大小关系不再是原来的顺序。这时你要做的不应该是从头到尾重新排序，而是找到平方后的自然规律。

再说一点，网上不少题解喜欢直接“先平方再排序”，但面试场景下，面试官更想看到你识别出双指针机会。O(n log n) 能过大部分测试，但作为一个学算法的人，还是要追求更优解。

4.2 从两端收集的指针写法

有序数组平方后的最大值一定在两端，最小值在中间。原因是：绝对值越大，平方越大；数组有序，所以最左边可能是一个绝对值很大的负数，最右边是一个很大的正数，中间位置的绝对值反而小。

既然最大值在两端，就可以用两个指针从两端往中间走，每次把较大的平方放到结果数组的末尾：

python复制def sorted_squares(nums):
    n = len(nums)
    res = [0] * n
    left, right = 0, n - 1
    pos = n - 1

    while left <= right:
        left_sq = nums[left] ** 2
        right_sq = nums[right] ** 2
        if left_sq > right_sq:
            res[pos] = left_sq
            left += 1
        else:
            res[pos] = right_sq
            right -= 1
        pos -= 1

    return res

这里最妙的一点是 pos 从结果数组的末尾往前填。这样就不需要最后再反转一次数组。

我第一次写的时候想当然地从结果数组开头填，结果发现每次都要决定“当前最小平方是哪个”，而最小值在中间，反而不好定位。后来意识到，从两头收最大值，天然就是从大到小生成结果，直接逆序填充就好。

4.3 这个题和归并排序的关系

从两端往中间填，本质上是一种“谁大谁先出来”的选择过程，很像归并排序中合并两个有序数组的思路。你可以把数组看成“负数部分平方后从大到小”和“非负数部分平方后从小到大”两个序列，但不用真的切分，两端指针自然就能完成合并。

如果以后遇到“两个有序数组合并成一整个有序数组”的题，你会发现它们用的是同一套思维：从有效的最值端开始比较，把结果放到对应位置。题刷多了之后，这种“不同题共用同一套底层思维”的感觉会越来越明显。

5. 长度最小的子数组：滑动窗口的本质是“右边界驱动，左边界收缩”

5.1 从暴力枚举到滑动窗口的思考路径

这道题要求找长度最小的连续子数组，使得子数组和大于等于 target。最暴力的做法是枚举每个起点和终点，计算区间和，时间复杂度 O(n^2)。

如果数组元素都是正整数，还能用前缀和加二分做：前缀和数组是单调递增的，枚举左端点，二分找右端点，时间复杂度 O(n log n)。这个优化已经不错了，但还可以继续降到 O(n)。

为什么滑动窗口能做到 O(n)? 核心原因是正整数数组的“单调性”：窗口右边界往右移动时，窗口和只会变大；左边界往右移动时，窗口和只会变小。有了这个单调性，左右指针就都可以只往一个方向走，不会回退。

5.2 窗口收缩的细节：什么时候更新最小长度

滑动窗口的标准写法是这样的：

python复制def min_subarray_len(target, nums):
    n = len(nums)
    ans = n + 1
    left = 0
    cur = 0

    for right in range(n):
        cur += nums[right]

        while cur >= target:
            ans = min(ans, right - left + 1)
            cur -= nums[left]
            left += 1

    return 0 if ans == n + 1 else ans

几个容易出错的地方：

• 更新最小长度必须在收缩之前。因为 left 增加后，窗口可能已经不再满足 cur >= target，这时候记录长度没有意义。
• 收缩要用 while 而不是 if。因为减去一个 nums[left] 后，可能仍然满足条件，需要继续收缩。
• ans 初始化为 n + 1，用来判断“是否存在这样的子数组”。如果最终仍为 n + 1，说明找不到，返回 0。

我第一次写的时候把 ans = min(ans, right - left + 1) 放在 while cur >= target 循环的最后，也就是收缩完之后，结果发现只要窗口一直满足条件，记录的长度总是偏短，因为 left 已经往前走了。后来才意识到，正确时机是收缩前，或者收缩过程中每次判断前都记录一次。

5.3 什么情况下滑动窗口会失效

滑动窗口不是万能的。如果数组中存在负数，窗口和的单调性就被破坏了。右边界增加时，窗口和可能变小；左边界收缩时，窗口和也可能变大。这种情况下，简单滑动窗口无法保证正确性，可能需要前缀和配合数据结构、单调队列等方法。

所以刷这道题时，不要只记代码，要记住它的前提：数组元素为正数。面试时如果遇到变体，不妨先问清楚数据范围，这会直接影响解法选择。

提示：滑动窗口可以理解成“右边界开车，左边界踩刹车”。右边界负责把窗口撑大，直到满足条件；左边界负责把窗口缩小，追求最短。两个方向都被单调性约束住，所以才能保持 O(n)。

6. 螺旋矩阵：模拟题最怕“凭感觉转”，适合用边界收缩

6.1 四条边如何设置开闭区间

螺旋矩阵是一道二维数组模拟题，看起来像是在“画圈”，实际上是在不断收缩一个矩形的边界。如果你靠肉眼想象每一步走到哪，非常容易越界；正确方法是维护上下左右四个边界：top、bottom、left、right。

每次循环填充当前矩形的一圈：

• 从左到右填充上边；
• 从上到下填充右边；
• 从右到左填充下边；
• 从下到上填充左边。

每填充完一条边，对应的边界就往内收缩一步。核心不变量是：当前还没有填充的矩阵范围就是 [top..bottom] x [left..right]。

python复制def generate_spiral(n):
    res = [[0] * n for _ in range(n)]
    top, bottom = 0, n - 1
    left, right = 0, n - 1
    num = 1

    while left <= right and top <= bottom:
        for j in range(left, right + 1):
            res[top][j] = num
            num += 1
        top += 1

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

        if top <= bottom:
            for j in range(right, left - 1, -1):
                res[bottom][j] = num
                num += 1
            bottom -= 1

        if left <= right:
            for i in range(bottom, top - 1, -1):
                res[i][left] = num
                num += 1
            left += 1

    return res

注意在填充下边和左边之前，要加 if top <= bottom 和 if left <= right 的判断。原因很简单：当矩阵只剩一行或一列时，填充完上边和右边，下边和左边可能已经不存在了，如果不判断就直接访问，会重复填充已经填过的位置，或者越界。

6.2 奇偶边长与最后的中心点

螺旋矩阵还有一个常见的边界问题：n 为奇数时，最中心会剩下一个单独的点；n 为偶数时，所有元素都会被完整地按圈填完。

上面的代码用边界收缩加条件判断，就能自然处理这个中心点。当 top == bottom 且 left == right 时，最后一次循环会填充中心位置，然后边界收缩，循环条件不满足，结束。不需要额外判断奇偶，省去不少麻烦。

如果你选择另一种写法，比如每层都使用左闭右开区间，那就要特殊处理奇数 n 的中心点，否则会漏填。两种写法都能用，但边界收缩加条件判断的写法，对不同规模的 n 更统一，也更不容易出错。

6.3 调试螺旋矩阵的一个技巧

我第一次写螺旋矩阵时，总是填着填着就乱了。后来找到一个很有效的调试方法：在循环里把 res 打印出来，每填完一条边就看一眼当前矩阵状态。你会发现：

• 填充上边后，只有第一行有值；
• 填充右边后，最后一列有值；
• 填充下边后，最后一行有值；
• 填充左边后，第一列有值。

通过打印中间状态，能很快发现边界收缩顺序的问题。比如有的人把 top 和 bottom 的收缩顺序写反，打印出来就会发现矩形范围乱了。

这个方法同样适用于矩阵旋转、蛇形遍历这类题。二维数组模拟题的共性就是：把边界变量写清楚，每走一步都想清楚当前边界是否已经收缩。边界对了，过程怎么模拟都不会错。

7. 这几类题做完后，我重新理解了“数组题的核心”

7.1 一个做题顺序建议

如果把这几篇笔记重新排一遍，我会建议你按这个顺序刷：

1. 二分查找：先理解“闭区间 / 开区间”和“循环不变量”，这是后续所有边界处理的基础。
2. 移除元素：用快慢指针理解“覆盖”和“有效区间”的概念。
3. 有序数组平方：把双指针从“同向”扩展到“两端向中间”的用法。
4. 长度最小子数组：理解滑动窗口的单调性和收缩时机。
5. 螺旋矩阵：把一维指针思维扩展到二维边界。

这个顺序的好处是：每一步都在上一步的基础上加一个新的抽象层次。不会一开始就被二维边界搞晕。

7.2 复盘时的自测清单

刷完并不算完，我建议每道题都做一次复盘，对照这份自测清单：

• 循环不变量是否写清楚了？区间是开还是闭？
• 每次循环区间是否一定缩小了？会不会出现死循环？
• 指针移动时，是否有元素被跳过或重复处理？
• 空数组、单元素数组、全部需要删除、答案在数组端点这些边界用例是不是都测了？
• 时间复杂度是否已经达到当前场景下的最优？
• 如果数组条件变化，比如出现负数，算法还成立吗？为什么？

能用这些问题把自己的解法问一遍，比自己闷头再刷十道题更有价值。我复习数组专题时，很多“原来没懂”的细节都是在这个环节补上的。

7.3 后续可以延伸的方向

数组专题不是孤立的。移除元素的快慢指针可以直接迁移到链表题；有序数组平方的两端指针可以延伸到“合并两个有序数组”；滑动窗口可以延伸到字符串子串问题；螺旋矩阵的边界收缩可以延伸到矩阵旋转、蛇形遍历、岛屿数量这类网格题。

我自己的体会是：数组题是所有算法专题里最值得先刷透的。不是因为简单，而是因为它能用最少的抽象，把“指针、边界、不变量、复杂度优化”这些底层能力全部练到。后面刷链表、字符串、矩阵、二叉树，很多手感都是从数组阶段建立起来的。

最后说一个我个人的习惯：每次刷完数组题，我会在白纸上把区间、指针移动方向、边界收缩顺序画一遍，不画出来就不算真懂。这个方法帮我少踩了很多边界坑，也希望对你有效。