LeetCode 283移动零：双指针原地算法详解与同类题通解

1. 从题目语义到双指针：为什么这题最优雅的答案是双指针

LeetCode 283这道题，难度标的是Easy，讨论区却比很多Medium还热闹。题目一句话就能说完：把数组里的0全部移到末尾，同时保持非零元素的相对顺序，并且必须原地操作。但它在面试里出现频率极高，因为它真正考的不是“你会不会把0挪走”，而是你具不具备双指针的直觉——用两个指针在O(n)时间、O(1)空间内完成数组分区。我见过不少候选人能答出解法，却说不清两个指针各代表什么，这正是今天想聊透的事。

1.1 题目真正要求的三件事

先别急着写代码，把题目拆开看，它其实同时提出了三个约束：

• 目标一：把数组中所有值为0的元素移动到数组末尾。
• 目标二：非零元素的相对顺序不能变。比如 [0, 1, 0, 3, 12] 处理后必须是 [1, 3, 12, 0, 0]，不能变成 [3, 1, 12, 0, 0]。
• 目标三：必须在原数组上操作，不能新建一个数组再拷贝回去，即空间复杂度要求O(1)。

三个约束叠加在一起，难度就上来了。目标一和目标二决定了你不能简单地把0“挑出来扔掉”或者“从后往前填”，因为一旦破坏顺序，结果就是错的。目标三则直接封死了“新建一个数组，把所有非零按顺序放进去，再在原数组里回写”这条看起来最直观的路——虽然它能通过用例，但不符合题目期望。

这里有一个初学者很容易忽略的点：题目说的是“移动零”，但核心其实是“保留非零”。 你不需要真的去“移动”0这个值，只需要把非零元素整体往前挪，让0自然“沉”到后面。想明白这一点，后续的双指针解法就顺理成章了。

1.2 为什么“新建数组”和“删除后补零”都不可行

我在面试模拟里见过不少候选人第一反应是“把0删掉，然后在末尾补同样数量的0”。这个思路本身没有错，但用错在数据结构上。数组的元素删除是O(n)操作，每删一个0，后续所有元素都要往前挪一位。如果数组里有k个0，整体复杂度会退化成O(n×k)，最坏情况是O(n²)。更致命的是，删除会让数组长度变化，边遍历边删在Python里很容易索引越界，在C++里则涉及vector迭代器失效问题。

新建数组的解法倒是能保住O(n)时间，但它需要O(n)空间。题目要求原地操作，面试官只要追一句“能不能把空间压到O(1)”，这条路就走不通。所以这道题的正确方向很明确：必须在一个数组内，用两个指针完成“分区”——左指针维护“已处理好的非零区域”，右指针不断向前扫描未处理的元素。

1.3 双指针为什么恰好命中要害

双指针的精髓，是用两个变量记录两个位置，让原本需要多次遍历的操作变成一趟扫描。移动零这个问题本质上是把数组分成两个区：左边是非零区，右边是零区。两个指针恰好对应这两个区域的交界处：

• 快指针（通常叫 i）负责遍历整个数组，相当于一个“侦察兵”，看看当前位置是不是非零元素。
• 慢指针（通常叫 j）负责指向“下一个非零元素应该放到的位置”，也就是非零区的末尾边界。

每当侦察兵发现一个非零元素，就把它交给慢指针“安放”到正确位置，慢指针向后移动一格。这样一趟扫描结束，所有非零元素都被按顺序放到了左半边，右半边剩下的位置自然全是0。整个过程不需要额外的数组，也不需要复杂的交换，两个指针各司其职，逻辑非常干净。

这个思路之所以是“最优雅”的，不是因为代码短，而是因为它把数组操作抽象成了“维护边界”的思维模型。一旦你习惯了这种模型，后面做移除元素、删除有序数组重复项、颜色分类等题目时，会发现它们全都是同一个套路的不同变体。这也是我在下文会专门用一章来展开“一题带一类”的原因。

2. 两种双指针写法：覆盖法与交换法

移动零的双指针实现，网上常见的是两种写法：覆盖法和交换法。两种都能通过，但背后对指针语义的理解略有差别。我建议你把两种都吃透，因为面试官很可能让你先写一种，再问“能不能优化”。

2.1 覆盖法：快指针搬值，慢指针占位

覆盖法的核心思想是：先把所有非零元素按顺序“搬”到前面，然后把剩余位置统一清零。慢指针 j 记录下一个非零元素要放置的位置，快指针 i 扫描整个数组。

C++版本：

cpp复制void moveZeroes(vector<int>& nums) {
    int n = nums.size();
    int j = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] != 0) {
            nums[j++] = nums[i];
        }
    }
    for (int k = j; k < n; k++) {
        nums[k] = 0;
    }
}

Python版本：

python复制def moveZeroes(nums):
    n = len(nums)
    j = 0
    for i in range(n):
        if nums[i] != 0:
            nums[j] = nums[i]
            j += 1
    for k in range(j, n):
        nums[k] = 0

我以 [0, 1, 0, 3, 12] 为例手动走一遍：

• i=0 时，nums[0]=0，跳过。
• i=1 时，nums[1]=1，赋值 nums[0]=1，j 变为1。
• i=2 时，nums[2]=0，跳过。
• i=3 时，nums[3]=3，赋值 nums[1]=3，j 变为2。
• i=4 时，nums[4]=12，赋值 nums[2]=12，j 变为3。
• 遍历结束，从 j=3 开始到数组末尾，依次置0。

最终数组变成 [1, 3, 12, 0, 0]。注意这个过程里，非零元素被“覆盖”到前面时，原来靠后的非零值确实被原地改写了，但因为后面统一补0，所以结果完全正确。覆盖法的优点在于逻辑直观、不容易写错，尤其适合刚接触双指针的读者。

2.2 交换法：快指针找非零，慢指针指向第一个零

交换法和覆盖法唯一的区别在于：快指针发现非零时，不是直接覆盖到慢指针位置，而是把该元素和慢指针指向的元素交换。这里有一个小优化——只有当 i != j 时才需要交换，否则就是在和自己交换。

C++版本：

cpp复制void moveZeroes(vector<int>& nums) {
    int n = nums.size();
    int j = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] != 0) {
            if (i != j) {
                swap(nums[i], nums[j]);
            }
            j++;
        }
    }
}

Python版本：

python复制def moveZeroes(nums):
    j = 0
    for i in range(len(nums)):
        if nums[i] != 0:
            nums[i], nums[j] = nums[j], nums[i]
            j += 1

同样用 [0, 1, 0, 3, 12] 走一遍：

• 初始 j=0，指向第一个0的位置。
• i=0，nums[0]=0，跳过。
• i=1，nums[1]=1，与 nums[0] 交换，数组变成 [1, 0, 0, 3, 12]，j=1。
• i=2，nums[2]=0，跳过。
• i=3，nums[3]=3，与 nums[1] 交换，数组变成 [1, 3, 0, 0, 12]，j=2。
• i=4，nums[4]=12，与 nums[2] 交换，数组变成 [1, 3, 12, 0, 0]，j=3。

可以看到，交换法在扫描过程中就逐步把0“挤”到右边，不需要最后单独补一轮清零。它的核心语义是：慢指针 j 始终指向“当前从左到右第一个值为0的位置”，快指针 i 每次把遇到的非零元素直接和这个0交换，交换后 j 指向的0自然就向右移动了。这个语义很有意思，它保证了数组在每一步扫描中都是“左侧非零、中间已处理、右侧未扫描”的状态。

2.3 两种写法的对比与选型

为了让你在实际刷题和面试时能快速决策，我把两种写法的差异整理成一个表格：

实际使用中，我个人的习惯是：在正式提交时用覆盖法，因为它的逻辑最直白，最后那个 range(j, n) 的循环很容易证明正确性；在讲解给面试官听时先讲交换法，因为它更贴近“双指针分区”这个耳熟能详的名词，而且能引出“优化点在于只在 i!=j 时交换”这种细节，给面试官留下考虑周全的印象。

但需要注意，两种方法的时间复杂度都是O(n)，空间复杂度都是O(1)，不存在谁更“快”的质变。真正的差别只是操作次数和代码风格的偏好。如果你在面试里被问到“能不能不额外清零”，那答案就是用交换法；如果被问到“最坏情况下写了几次”，就需要进入第三章的复杂度细节分析。

3. 边界条件与复杂度：最容易翻车的地方

LeetCode 283看起来简单，但提交一次就想通过并不容易。问题基本都出在边界条件和“最小化操作次数”的理解上。这一章把容易踩的坑单独拆开讲。

3.1 空数组、单个元素、全零数组

先看几个极端用例：

• nums = []：任何循环都不会执行，返回空数组即可，不报错。
• nums = [0]：遍历发现一个0，跳过，最后没有需要置零的位置，原样返回。
• nums = [1]：遍历发现一个非零，覆盖法里 nums[0]=1（自己赋给自己），j=1，最后 range(1, 1) 不执行，原样返回。
• nums = [0, 0, 0]：遍历全程没有非零，j 始终是0，覆盖法最后把整个数组都置0，结果正确。
• nums = [1, 2, 3, 4]：遍历时每个元素都被写到自己原来的位置，j 最终等于数组长度，后面没有需要置零的区间。

从这些用例可以看到，覆盖法和交换法在极端情况下都不会越界，但有个细节值得注意：Python 的 range(j, n) 当 j 等于 n 时是一个空范围，不会执行；C++ 的 for (int k = j; k < n; k++) 条件判断直接失败，也不会执行。 所以最后那个清零循环天然是安全的。我见过有人因为担心越界，额外加了一堆 if 判断，实际上完全没必要。

另一个容易忽略的点是：题目只要求把0移到末尾，并没有规定数组中不能出现负数。 比如 [-1, -2, 0, 3]，处理后的正确结果是 [-1, -2, 3, 0]。因为判断条件是 nums[i] != 0，负数和正数一样都属于“非零”，都会参与向前搬移。千万不要写成 if nums[i] > 0，那是另一个完全不同的问题。

3.2 操作次数视角：覆盖法和交换法谁更“省”

题目描述里有句话叫“最小化操作次数”，很多刷题者会下意识认为交换法因为“遍历一轮就完成”所以操作更少，其实数值上并不总是如此。我们来拆解一下。

假设数组长度为 n，非零元素数量为 m，那么0的数量就是 n - m。

覆盖法的写操作次数是这样分布的：

• 扫描阶段：每遇到一个非零元素，就把它写到慢指针位置，共 m 次赋值。
• 清零阶段：从 j 到 n-1，共 n - m 个位置需要置0。

加起来总共是 m + (n - m) = n 次写操作。这是一个恒定的数字，与0的位置无关。

交换法的写操作次数分布则不同：

• 每遇到一个非零元素，就和慢指针位置交换。交换一次涉及两次写操作。
• 在理想情况（前面没有堆积的0）下，交换可能是 i == j 的自我交换，如果加上 if (i != j) 判断，这种自我交换会被跳过。
• 最坏情况，比如数组是 [0, 1, 2, 3, ..., n-1]，慢指针一直停留在0，快指针每遇到一个非零都要交换，交换次数就是 n - 1，对应写操作次数约 2 * (n - 1)。

所以从绝对的写次数来看，覆盖法通常更省。这也是为什么很多资深刷题者推荐覆盖法作为“标准答案”——它虽然多了一个循环，但总的赋值次数是恒定的 n 次。交换法的优势是“单趟交换、没有后续清零循环”，在代码可读性上有一定优势，但最坏情况下的写次数其实更多。

3.3 稳定性的本质：为什么相对顺序必然保持

“保持非零元素相对顺序”是这道题的另一条硬约束。双指针解法为什么会天然满足这一条？理解这个问题比背结论重要。

原因在于两个指针的移动方向是单向且同步的：

• 快指针 i 从头到尾扫描，它拿到非零元素时，是按照它们在原数组中的顺序逐个拿到的。
• 慢指针 j 也是递增的，非零元素被放置的位置从小到大排列。

也就是说，先被快指针发现的非零元素，一定放在慢指针更靠前的位置；后被发现的，一定放在更靠后的位置。这个顺序关系和原数组完全一致，所以不会出现“后面的非零元素跑到前面的非零元素前面”这种错位情况。

对比一下，如果你用“从后往前扫描、把0往后推”的暴力方法，很容易在某次交换时把两个非零元素的相对位置搞乱，结果数组末尾的0是补齐了，但非零顺序却被破坏了。这也是为什么题目描述里特别强调“保持相对顺序”——这个约束直接淘汰了相当一部分“看似能跑”的算法。

4. 一题带一类：283是如何延伸到移除元素和去重的

LeetCode 283的价值不在一道题本身，而在于它是双指针入门的一个“最小完备样本”。把这道题吃透，你会发现27题、26题，甚至75题，本质上都是同一个思维模型换了个判断条件。

4.1 27. 移除元素：把“等于val”当作“零”

27题的描述是：给你一个数组 nums 和一个值 val，原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。注意它不要求把 val 放到末尾，而是要求返回新长度，数组的前 k 个位置就是移除后的结果。

对比一下283，你会发现几乎可以逐行翻译：

python复制def removeElement(nums, val):
    j = 0
    for i in range(len(nums)):
        if nums[i] != val:
            nums[j] = nums[i]
            j += 1
    return j

这个版本的代码和283覆盖法的扫描阶段一模一样，只是把 != 0 换成了 != val，并且不需要最后的清零循环，因为题目根本不在乎 val 之后剩什么。看到这你应该能理解，掌握283的覆盖法，27题基本就是送分题。

不过有一个差异值得注意：27题返回值是“新长度”，所以要把 j 返回出去；283题没有返回值，直接修改原数组即可。很多人在27题里忘记返回 j，导致提交结果错误，这就是对“这题到底要我返回什么”理解不够清楚。

4.2 26. 删除有序数组中的重复项：判断条件换成了“与前一个不同”

26题要求原地删除有序数组中的重复项，使每个元素只出现一次，并返回新长度。由于数组是有序的，重复元素一定是相邻的。因此快指针的任务从“找非零”变成了“找第一次出现的新元素”。

python复制def removeDuplicates(nums):
    if not nums:
        return 0
    j = 0
    for i in range(1, len(nums)):
        if nums[i] != nums[j]:
            j += 1
            nums[j] = nums[i]
    return j + 1

这里慢指针 j 的语义稍微变了：它指向“最后一个已经确认的唯一元素”，而非“下一个写入位置”。快指针 i 从1开始，每次都和 nums[j] 比较。如果当前元素不等于最后一个唯一元素，说明它是一个新值，于是 j 先加1，再把新值写到新位置。

注意这里有个细节：j 的初始值是0，因为第一个元素一定保留；返回值是 j + 1，因为长度为索引加1。这个差别很容易被忽视，如果你直接从283搬代码而不思考指针语义，很容易在边界上出错。

4.3 75. 颜色分类：双指针升级成三指针分区

75题“颜色分类”要求把只包含0、1、2的数组原地排序成所有0在前、所有1在中间、所有2在后。这是一个比283更复杂的分区问题，需要三个变量——一个 left 维护0区边界，一个 right 维护2区边界，一个 cur 扫描中间。

核心逻辑是：

• 遇到0，与 left 交换，left 和 cur 都向后移动。
• 遇到2，与 right 交换，right 向前移动，cur 不移动（因为交换回来的值需要再判断）。
• 遇到1，cur 直接向后移动。

你会发现，这个思路就是从283的“仅分区非零和零”扩展到“分区0、1、2”三层。三指针本质上就是多个双指针的组合。如果你能把283的“慢指针维护边界”想明白，75题的大致框架一眼就能看穿。

4.4 怎么一眼认出“这题能用双指针”

结合上面的例子，我总结出三个特征，满足任意两个就优先考虑双指针：

• 要求在原数组上操作，空间复杂度限死为O(1)。
• 要求保持某种相对顺序，比如非零元素的顺序、去重后的顺序。
• 问题可以抽象成把数组分成两个或三个逻辑区域，比如“非零区 / 零区”、“已保留区 / 待处理区”。

当一道题同时具备这三个特征时，它的核心解法几乎必然是双指针。你不需要一开始就写出最优解，但至少要在五分钟内意识到“这题可以用双指针扫一遍”。这种直觉的培养，靠的就是像283这样的小题反复练。

5. 实战经验：我写这道题时踩过的坑和自测清单

最后这部分，分享一下我在实际写这道题和面试别人时反复看到的坑。有的坑看起来不起眼，但真到白板写代码或者限时提交时，它们会狠狠咬你一口。

5.1 四个高频bug

第一个bug：覆盖法最后置零时写成了 range(j, n-1)，导致最后一个位置没有被清零。比如 [1, 2, 3, 0, 0] 本来已经正确，但如果最后一个元素是0且落到倒数第二个位置，结果就会在末尾残留一个非零值。这个bug在Python里尤其隐蔽，因为不报错。

第二个bug：交换法里把 i != j 的判断加上了，却忘了在交换后自增 j。你会发现数组明明没有变化，但 j 没动，导致后续所有交换都挤在同一个位置。代码逻辑上没有任何编译错误，但运行结果完全不对。

第三个bug：在Python里试图用 del 边遍历边删除0。这是初学者最常见的错误，因为 del 会改变数组长度，导致 for i in range(len(nums)) 里的索引和实际数组长度不一致，轻则越界，重则漏掉元素。记住，数组题目里的“删除”一定是用覆盖或交换来模拟，而不是真的调用删除接口。

第四个bug：把第一个非零判断写成 if nums[i] > 0。如果数组中存在负数，这些负数会被当作0处理，导致它们被错误地移到末尾。题目从来没有说明数组里只有非负整数，所以判断必须是 != 0。

5.2 推荐的自测用例

写完代码先别急着提交，用下面这组用例测一遍：

最后两条用例能帮你快速排查第5.1节里提到的第四个bug——如果你写了 nums[i] > 0，-1 和 -2 会被错误地丢到后面，测试结果会立刻暴露问题。

5.3 面试时怎么把思路讲得又快又清楚

我在模拟面试中常用一个“两段式”讲解法，效果不错。

第一段，用一句话说清整体思路：“我用快指针扫描数组，用慢指针维护一个边界，边界左边是所有处理好的非零元素。每当快指针发现非零，就把它写到慢指针位置，然后慢指针前进。”

第二段，选一个具体例子现场模拟两轮，比如 [0, 1, 0, 3]。演示到 i=1 时 nums[0]=1，j 到1；再到 i=3 时 nums[1]=3，j 到2。然后说：“最后从 j 到数组末尾统一置0，得到 [1, 3, 0, 0]。”

这两步走完，面试官基本已经确认你理解了解法。之后他大概率会追问：“空间复杂度是多少？”“为什么不会破坏非零元素的相对顺序？”“能不能只遍历一次完成？”这些问题在本文第二、三章都已经覆盖，你只需要用自己的话复述一遍即可。

根据我个人的经验，283这道题刷透之后，最大的收获不是会做这一道题，而是建立了“双指针+数组分区”的思维框架。之后你再遇到27题、26题、75题，会自然地想“这不就是283换了个判断条件吗”。刷题要的不是背代码，而是背这种指针语义。把283的两个指针各自代表什么、为什么这么设计搞清楚，很多所谓的“新题”其实都是老朋友。