零、题目描述
一、为什么这道题值得你花几分钟看懂？
二、题目拆解：提取其中的关键点
三、明确思路：双指针的巧妙配合
四、算法实现：双指针的代码演绎
五、C++代码实现：一步步拆解
- 代码拆解
- 时间复杂度和空间复杂度
六、实现过程中的坑点总结
七、举一反三

零、题目描述

题目链接：移动零

题目描述：
在这里插入图片描述

示例 1：
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2：
输入: nums = [0]
输出: [0]

提示：
1 <= nums.length <= 10^4
-2^31 <= nums[i] <= 2^31 - 1

一、为什么这道题值得你花几分钟看懂？

如果你正在打磨自己的算法基础，那「移动零」这道题你一定不能错过——它是 LeetCode 第 283 题，更是双指针技巧的经典入门题，几乎所有算法入门教程都会拿它举例。

从算法能力提升来讲，这道题能帮你深刻理解双指针在原地修改数组中的核心作用，掌握「快慢指针配合」的精髓。这种技巧不仅能解决数组中的元素移动问题，还能延伸到链表操作、滑动窗口等多种场景，是很多高效算法的基础。

甚至在实际开发中，当需要对数据进行过滤、整理，又希望节省空间时，双指针的思路能帮你写出更高效、更优雅的代码。

二、题目拆解：提取其中的关键点

先看原题：

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。必须在不复制数组的情况下原地对数组进行操作。

再结合所给的代码框架和提示：

class Solution {
public:void moveZeroes(vector<int>& nums) {}
};

核心要素提炼：

输入是一个整数类型的向量nums，需要对其进行原地修改。
操作目标是将数组中的所有0移到末尾，同时保证非零元素的相对顺序不变。
不能使用额外的数组来辅助，必须在原数组上进行操作。

关键点：

双指针应用：用两个指针分别追踪非零元素的位置和当前遍历的位置。
元素交换：将非零元素移动到前面合适的位置。
保持顺序：确保非零元素的相对位置和原来一致。
原地操作：不使用额外的数组空间，只在原数组上进行修改。

三、明确思路：双指针的巧妙配合

1. 最直观的想法：先移非零，再补零

拿到题的第一反应：把所有非零元素按顺序移到数组前面，然后把剩下的位置都填上0。比如对于数组[0,1,0,3,12]，先把非零元素1、3、12依次移到前面，得到[1,3,12,...]，再把后面的位置补成0，结果就是[1,3,12,0,0]。

这种思路的关键是如何高效地找到非零元素应该放置的位置，这就需要用到双指针了。

2. 双指针的分工

在这里，我们可以用两个指针：

cur指针：负责遍历整个数组，寻找非零元素，相当于“探索者”。
dest指针：负责记录下一个非零元素应该放置的位置，相当于“占位者”。

初始时，cur从数组开头开始遍历，dest指向-1（表示还没有确定非零元素的位置）。当cur遇到非零元素时，就把dest向前移动一位，然后交换cur和dest指向的元素。这样，dest始终指向已经处理好的非零元素的最后一个位置。

举个例子（示例1）：

初始数组：[0,1,0,3,12]，cur=0，dest=-1
cur=0，元素是0，不做操作，cur++
cur=1，元素是1（非零），dest++变为0，交换nums[0]和nums[1]，数组变为[1,0,0,3,12]，cur++
cur=2，元素是0，不做操作，cur++
cur=3，元素是3（非零），dest++变为1，交换nums[1]和nums[3]，数组变为[1,3,0,0,12]，cur++
cur=4，元素是12（非零），dest++变为2，交换nums[2]和nums[4]，数组变为[1,3,12,0,0]，cur++
遍历结束，得到结果

3. 为什么这样可行？

因为cur指针一直在dest指针前面或者和它同步，dest指针前面的元素都是已经处理好的非零元素，并且保持着原来的相对顺序。当cur遇到非零元素时，把它交换到dest+1的位置，就保证了非零元素按原来的顺序排列在前面，而后面剩下的位置自然都是0了。

这种方法只需要遍历一次数组，并且是原地操作，时间复杂度是O(n)，空间复杂度是O(1)，非常高效。

四、算法实现：双指针的代码演绎

这道题我用双指针的方法来实现，下面讲解具体的算法思路。

核心逻辑：
用cur指针遍历数组，当遇到非零元素时，将dest指针向前移动一位，然后交换cur和dest指向的元素，这样就能把非零元素逐步移到前面，零自然就到后面去了。

步骤拆解：

初始化cur为0，dest为-1。
用cur遍历数组中的每个元素：
- 若nums[cur]是非零元素：
  - 将dest向前移动一位（dest++）。
  - 交换nums[cur]和nums[dest]。
- cur向前移动一位（cur++）。
遍历结束后，数组中的所有零都被移到了末尾，非零元素保持相对顺序不变。

双指针细节：

cur指针：从0开始，依次遍历数组的每个元素，直到数组末尾。它的作用是发现非零元素。
dest指针：初始值为-1，表示还没有非零元素被放置。每当cur找到一个非零元素，dest就向前移动一位，指向这个非零元素应该放置的位置。
交换操作：当cur找到非零元素时，交换nums[cur]和nums[dest]，这样非零元素就被放到了前面合适的位置。
遍历顺序：cur始终从左到右遍历，保证了非零元素的相对顺序不变。

五、C++代码实现：一步步拆解

完整代码（附详细注释）：

#include <vector>
using namespace std;class Solution {
public:void moveZeroes(vector<int>& nums) {int n = nums.size();// cur用于遍历数组，dest用于记录非零元素应放的位置for (int cur = 0, dest = -1; cur < nums.size(); cur++) {if (nums[cur] != 0) {  // 遇到非零元素dest++;  // dest移动到下一个位置swap(nums[dest], nums[cur]);  // 交换元素，将非零元素放到前面}}}
};

代码拆解

1. 变量初始化

int n = nums.size();  // 获取数组长度，虽然这里没有直接使用，但可以用于后续扩展
int cur = 0;  // 遍历指针，从数组开头开始
int dest = -1;  // 目标指针，初始为-1，表示还没有非零元素被放置

作用：cur负责遍历整个数组，dest负责跟踪非零元素应该放置的位置，初始状态下还没有非零元素被处理，所以dest为-1。

2. 主循环逻辑

for (int cur = 0, dest = -1; cur < nums.size(); cur++) {// 循环条件：cur遍历完数组的所有元素if (nums[cur] != 0) {  // 当遇到非零元素时dest++;  // 目标位置向前移动一位swap(nums[dest], nums[cur]);  // 交换元素，将非零元素放到目标位置}// 如果是零元素，则不做处理，cur继续向前移动
}

核心设计：

遍历机制：cur从0开始，每次循环后自增1，直到遍历完整个数组，确保每个元素都被检查。
非零元素处理：当nums[cur]不是0时，说明找到了一个需要放到前面的元素。此时dest先自增1，指向当前应该放置非零元素的位置，然后交换nums[cur]和nums[dest]，这样非零元素就被放到了前面。
零元素处理：当nums[cur]是0时，不做任何操作，cur继续向前移动，零元素就被留在了原地，最终会被后面的非零元素交换到后面去。

示例走读（示例1：nums = [0,1,0,3,12]）

步骤	cur	dest	nums[cur]	操作	数组状态
初始	0	-1	0	不操作，cur++	[0,1,0,3,12]
1	1	-1	1	dest++变为0，交换nums[1]和nums[0]，cur++	[1,0,0,3,12]
2	2	0	0	不操作，cur++	[1,0,0,3,12]
3	3	0	3	dest++变为1，交换nums[3]和nums[1]，cur++	[1,3,0,0,12]
4	4	1	12	dest++变为2，交换nums[4]和nums[2]，cur++	[1,3,12,0,0]
结束	5（退出循环）	2	-	-	[1,3,12,0,0]

通过这个过程可以清晰地看到，非零元素1、3、12依次被放到了数组前面，零元素被移到了后面，并且非零元素的相对顺序保持不变。

时间复杂度和空间复杂度

复杂度类型	具体值	说明
时间复杂度	O(n)	n是数组的长度，`cur`指针遍历整个数组一次，每个元素最多被交换一次
空间复杂度	O(1)	只使用了两个额外的指针变量，没有使用额外的数组或其他数据结构

这种算法在时间和空间上都非常高效，符合题目的要求。

六、实现过程中的坑点总结

dest指针的初始值
错误写法：
```
for (int cur = 0, dest = 0; cur < nums.size(); cur++) {// ...
}
```
问题：如果dest初始化为0，当数组的第一个元素是非零元素时，会把它和自己交换，虽然结果正确，但做了无用功。更重要的是，如果数组全是零元素，可能会出现不必要的操作。
正确做法：初始化为-1，让第一个非零元素能正确地放到索引0的位置。
忘记交换元素
错误写法：
```
if (nums[cur] != 0) {dest++;nums[dest] = nums[cur];  // 直接赋值，没有处理原来的位置
}
```
问题：这样会导致原来dest位置的元素被覆盖，而cur位置的非零元素没有被清除，可能会留下重复的值。
正确做法：使用swap函数交换两个位置的元素，确保非零元素移动的同时，零元素被换到后面。
遍历顺序错误
错误写法：
```
for (int cur = nums.size() - 1; cur >= 0; cur--) {// ...
}
```
问题：从后往前遍历会打乱非零元素的相对顺序，无法保证移动后非零元素的顺序和原来一致。
正确做法：cur指针必须从左到右遍历数组，才能保证非零元素的相对顺序不变。
处理空数组或只有一个元素的情况
虽然代码中没有专门处理，但当前的代码逻辑对这些情况是兼容的：
- 如果数组为空，循环不会执行，直接返回。
- 如果数组只有一个元素，无论是0还是非零，循环执行一次后都会得到正确的结果。
不必要的交换
当cur和dest相等时（比如数组开头都是非零元素），交换操作是不必要的。可以添加一个判断来优化：
```
if (nums[cur] != 0) {dest++;if (cur != dest) {  // 只有当位置不同时才交换swap(nums[dest], nums[cur]);}
}
```
这样可以减少一些无用的交换操作，提高代码效率。