移除元素：原地删除 · 快慢指针

怎样从“数组 nums=[3,2,2,3]，要把等于 val=3 的元素全部「删除」（原地）。”推导出 数组写游标 · 快慢指针，并证明每次状态变化都不会漏掉答案？

中心结论：fast 是读指针，从左到右扫描每个元素；slow 是写指针，指向下一个可写位置。nums[fast]!=val 时把它写到 nums[slow] 并 slow++；等于 val 直接跳过。结束后 nums[0:slow] 就是答案。

给定一个数组 nums 和一个数值 val，将数组中所有等于 val 的元素删除，并返回剩余的元素个数。

在本站主例中，数组 nums=[3,2,2,3]，要把等于 val=3 的元素全部「删除」（原地）。

算法最终需要得到或观察：返回 slow=2；nums[0:2]=[2,2] 是结果，后面位置 LeetCode 不会检查。

为每个位置复制或删除元素，会产生重复搬运；先建立正确基线，再把有效元素原地覆盖到写指针位置。

暴力方案的价值是确认题意并提供正确性基线。它通常会覆盖所有候选， 但没有保存已经确认的信息，因此同一状态会被重新计算。

1. 1建模把输入翻译成“读写游标”，明确答案需要观察什么。
2. 2状态只维护 fast（读，蓝色）从左到右扫；slow（写，橙色）只在写入时前移；nums[0:slow] 是已确认结果区。
3. 3转移每一步按照 fast 是读指针，从左到右扫描每个元素；slow 是写指针，指向下一个可写位置。nums[fast]!=val 时把它写到 nums[slow] 并 slow++；等于 val 直接跳过。结束后 nums[0:slow] 就是答案。
4. 4收尾读取 返回 slow=2；nums[0:2]=[2,2] 是结果，后面位置 LeetCode 不会检查。，并复核边界与复杂度。

读指针负责发现信息，写指针只在答案确定时落笔。

这道题不是为了记住一个组件名称，而是为了让状态具有可解释的语义：fast（读，蓝色）从左到右扫；slow（写，橙色）只在写入时前移；nums[0:slow] 是已确认结果区。

这道题和第 283 题很像。这道题和第 283 题基本一致，283 题是删除 0，这一题是给定的一个 val，实质是一样的。

这里数组的删除并不是真的删除，只是将删除的元素移动到数组后面的空间内，然后返回数组实际剩余的元素个数，OJ 最终判断题目的时候会读取数组剩余个数的元素进行输出。

fast 是读指针，从左到右扫描每个元素；slow 是写指针，指向下一个可写位置。nums[fast]!=val 时把它写到 nums[slow] 并 slow++；等于 val 直接跳过。结束后 nums[0:slow] 就是答案。

执行过程中持续维护：fast（读，蓝色）从左到右扫；slow（写，橙色）只在写入时前移；nums[0:slow] 是已确认结果区。

正确性依赖以下不变量：slow ≤ fast 恒成立。；下标区间 [0, slow) 是已确定结果区,只含应保留的元素。；在任意时刻,nums[0:slow] 永远是已经确定的结果区。

面试时可以压缩为：我用快慢指针原地改写:fast 扫描数组,遇到不等于目标值的元素就写到 slow 处并前移 slow;返回 slow 即新长度,时间 O(n)、空间 O(1)。

落到当前题，执行机制可以压缩为：fast 是读指针，从左到右扫描每个元素；slow 是写指针，指向下一个可写位置。nums[fast]!=val 时把它写到 nums[slow] 并 slow++；等于 val 直接跳过。结束后 nums[0:slow] 就是答案。每一次更新都必须保持核心不变量，而不是只让样例碰巧得到正确答案。

1. 1初始化指针传送带上的箱子已就位。接下来 fast 从左到右逐个检查 nums[fast]；slow 只在遇到要保留的元素时写入并前移。 因为：「删除」不是把数组中间真的挖掉——只是把要保留的元素覆盖到数组前面，最后告诉调用者前 k 个有效。
2. 2fast = 0巡检员在位置 0 看到 3，正好等于 val。不写入合格区，slow 继续停在 0。 因为：等于 val 的元素就是要拦截的目标，slow 不动以等待下一个可保留的值。
3. 3fast = 1巡检员在位置 1 看到 2，不等于 val。这个值将被搬到合格区位置 0。 因为：slow 指向下一个可写位置——保留的元素就写在这里，然后 slow 右移把这个位置「冻结」为结果。
4. 4完成写入 nums[0]合格区位置 0 现在是 2，slow 前移到 1。slow 左侧都是已确认结果。 因为：slow 走过的步数 = 已保留元素个数；被覆盖的旧值不再重要。
5. 5fast = 2巡检员在位置 2 看到 2，不等于 val。这个值将被搬到合格区位置 1。 因为：slow 指向下一个可写位置——保留的元素就写在这里，然后 slow 右移把这个位置「冻结」为结果。
6. 6完成写入 nums[1]合格区位置 1 现在是 2，slow 前移到 2。slow 左侧都是已确认结果。 因为：slow 走过的步数 = 已保留元素个数；被覆盖的旧值不再重要。
7. 7fast = 3巡检员在位置 3 看到 3，正好等于 val。不写入合格区，slow 继续停在 2。 因为：等于 val 的元素就是要拦截的目标，slow 不动以等待下一个可保留的值。
8. 8循环结束fast 越界跳出 for。返回 slow=2。nums[0:2]=[2, 2] 就是答案，后面内容 LeetCode 不会检查。 因为：slow 走过的步数 = 保留下来的元素个数 = 答案 k。这就是为什么直接返回 slow。

代码窗口不会按容易漂移的固定数字行号硬绑动画，而是根据当前语义阶段， 在完整 Go 实现中定位选择、计算、写回或返回分支。当前变量与高亮行一起变化。

func removeElement(nums []int, val int) int {
	if len(nums) == 0 {
		return 0
	}
	j := 0
	for i := 0; i < len(nums); i++ {
		if nums[i] != val {
			if i != j {
				nums[i], nums[j] = nums[j], nums[i]
			}
			j++
		}
	}
	return j
}

func main() {
    // 1. 主例
    //    输入：mode="remove-value", array=[3,2,2,3], removeValue=3
    //    期望：返回 slow=2；nums[0:2]=[2,2] 是结果，后面位置 LeetCode 不会检查。
    //
    // 2. 失败 / 未命中
    //    检查：写入后忘记 slow++,会让下一个保留值覆盖刚写好的元素。
    //
    // 3. 边界
    //    空输入、单元素、最小合法规模，以及答案恰好落在边界的情况。
    //
    // 4. 迁移
    //    LC26 有序数组去重；LC283 移动零
}

Go 参考实现基于 halfrost/LeetCode-Go 的 MIT 许可代码整理，并按本站教学结构补充解释与动画映射。

1. 1题意数组 nums=[3,2,2,3]，要把等于 val=3 的元素全部「删除」（原地）。
2. 2重复为每个位置复制或删除元素，会产生重复搬运；先建立正确基线，再把有效元素原地覆盖到写指针位置。
3. 3优化fast 是读指针，从左到右扫描每个元素；slow 是写指针，指向下一个可写位置。nums[fast]!=val 时把它写到 nums[slow] 并 slow++；等于 val 直接跳过。结束后 nums[0:slow] 就是答案。
4. 4证明slow ≤ fast 恒成立。；下标区间 [0, slow) 是已确定结果区,只含应保留的元素。；在任意时刻,nums[0:slow] 永远是已经确定的结果区。
5. 5复杂度时间 O(n)，空间 O(1)