一、26. 删除有序数组中的重复项
题目:
给你一个 非严格递增排列 的数组 nums ,请你**原地** 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
考虑 nums 的唯一元素的数量为 k。去重后,返回唯一元素的数量 k。
nums 的前 k 个元素应包含 排序后 的唯一数字。下标 k - 1 之后的剩余元素可以忽略。
示例:
示例 1:
输入:nums = 1,1,2
输出:2, nums = 1,2,_**
解释:函数应该返回新的长度 2,并且原数组 nums 的前两个元素被修改为 1,2。不需要考虑数组中超出新长度后面的元素。
示例 2:
输入:nums = 0,0,1,1,1,2,2,3,3,4
*输出:5, nums = 0,1,2,3,4,_* *,_* ,_*,_,_*
解释:函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0,1,2,3,4。不需要考虑数组中超出新长度后面的元素。
提示:
1 <= nums.length <= 3 * 104-100 <= nums[i] <= 100nums已按 非递减 顺序排列。
总结一下,题目要求就是给定一个按非递减顺序排列的数组,原地删除重复元素,使每个元素只出现一次,并返回处理后的数组长度。返回值之后的内容不需要关心。
1.为什么可以使用双指针?
因为数组有序,相同元素必然连续出现。因此,我们不需要哈希表,也不需要反复查找,只需在扫描过程中识别"新值"。
定义两个指针:
slow:指向已保留区间的最后一个元素。
fast:指向当前待判断的元素,依次扫描整个数组。
初始时,第一个元素必然保留,所以 slow = 0、fast = 1。
接下来存在两种情况:
- 如果
nums[fast] == nums[slow],说明当前元素与已保留元素重复,只移动fast。 - 如果
nums[fast] != nums[slow],说明发现了新值。先执行++slow,再把nums[fast]写入nums[slow]。
核心操作可以概括为:
发现新值 → ++slow → nums[slow] = nums[fast]
2. 动画演示
示例输入:[0, 0, 1, 1, 1, 2, 2, 3, 3, 4]。
蓝色区域表示当前已经保留的有效前缀,橙色表示 fast 当前扫描的元素,紫色表示参与比较的元素,绿色表示本轮发生写入的位置。

3. 对应代码
cpp
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if (nums.empty()) return 0;
int slow = 0;
for (int fast = 1; fast < nums.size(); ++fast) {
if (nums[slow] != nums[fast]) {
nums[++slow] = nums[fast];
}
}
return slow + 1;
}
};
这里返回 slow + 1,是因为 slow 表示最后一个有效元素的下标 ,而题目要求返回有效元素的数量。
复杂度分析:
- 时间复杂度:
O(n),fast从左到右扫描一次。
- 空间复杂度:
O(1),只使用固定的指针变量。
二、80. 删除有序数组中的重复项 II
题目:
给定一个按 非递减顺序 排列的整数数组 nums,请你 原地 删除部分重复元素,使得每个不同的元素 最多出现两次 。元素的 相对顺序 应保持 不变。
由于在某些语言中无法改变数组的长度,因此必须将结果放在数组 nums 的前半部分 。更准确地说,如果删除重复元素后有 k 个元素,那么 nums 的前 k 个元素应该保存最终结果。前 k 个元素之后的内容无关紧要。
将最终结果放入 nums 的前 k 个位置后,返回 k。
不要 为另一个数组分配额外空间。你必须使用 O(1) 的额外内存,通过 原地 修改输入数组来完成此操作。
示例:
示例 1:
输入: nums = 1,1,1,2,2,3
输出: 5, nums = 1,1,2,2,3,_
解释: 你的函数应该返回 k = 5,并且 nums 的前五个元素分别为 1、1、2、2 和 3。
返回的 k 之后的元素是什么并不重要(因此用下划线表示)。
示例 2:
输入: nums = 0,0,1,1,1,1,2,3,3
输出: 7, nums = 0,0,1,1,2,3,3,_,_
解释: 你的函数应该返回 k = 7,并且 nums 的前七个元素分别为 0、0、1、1、2、3 和 3。
返回的 k 之后的元素是什么并不重要(因此用下划线表示)。
第二题只改变了保留规则:每个元素最多出现两次。
**方法1:**按数值分段,并用计数器限制写入次数
一种直接的扩展方式是:先识别当前正在扫描的数值段,再只允许该段的前两个元素写入结果区。
这种方法使用四个变量:
slow:当前数值段的起始下标,用来识别是否遇到了新值。
fast:当前扫描下标。
idx:结果区的下一个写入位置。
cnt:当前段内的写入控制标记。处理第 1、2 个元素时其值分别为 1、2;写入两个后变为 3,之后保持为 3。
这里需要特别注意:cnt 并不是持续累加的重复元素总数 ,而是一个用于判断是否还能继续写入的控制标记。
1. 遇到新值时,为什么 fast 不前进?
当 nums[slow] != nums[fast] 时,说明扫描到了新的数值段。本轮只执行:
cpp
cnt = 1;
slow = fast;
此时 fast 不前进。下一轮循环会重新处理这个元素,并把新数值段的第一个元素写入结果区。
2. 动画演示
示例输入:[1, 1, 1, 2, 2, 3]。

3. 对应代码
cpp
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int size = nums.size();
if (size <= 2) return size;
int slow = 0;
int fast = 0;
int idx = 0;
int cnt = 1;
while (fast < size) {
if (nums[slow] == nums[fast]) {
if (cnt <= 2) {
nums[idx++] = nums[fast];
cnt++;
}
fast++;
} else {
cnt = 1;
slow = fast;
}
}
return idx;
}
};
当数组长度不超过 2 时,无论元素是否重复都天然符合要求,直接返回原长度即可;这也同时覆盖了空数组。
复杂度分析:
- 时间复杂度:
O(n)。虽然遇到新值时会多经历一次状态重置,但这种重置最多发生n - 1次。
- 空间复杂度:
O(1)。
这种方法比较直观,但变量较多,状态维护也稍繁琐。
方法2:直接判断结果区是否已经保留两个
更简洁的思路是:不再记录原始数值段,而是只观察已经写好的结果区。
当前候选元素能否保留,由结果区末尾的元素就能判断。
1. 为什么比较 numsslow - 2?
令 k = 2,并让 slow 表示下一个写入位置。
数组的前两个元素无论是否相同都可以保留,因此初始化:
cpp
slow = 2
fast = 2
对于候选值 nums[fast],比较 nums[slow - 2]:
- 如果二者相等 ,由于数组有序且结果区保持原顺序,
nums[slow - 2]到nums[slow - 1]已经是连续两个相同值。再写入当前值就会超过两个,所以跳过。
- 如果二者不同,结果区末尾至多只有一个与当前值相同的元素,或者当前值根本是新值,因此可以写入。
于是,核心判断变成:
cpp
nums[fast] != nums[slow - k] → nums[slow++] = nums[fast]
2. 动画演示
仍使用输入:[1, 1, 1, 2, 2, 3]。

3. 对应代码
cpp
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int size = nums.size();
if (size <= 2) return size;
const int k = 2;
int slow = k;
for (int fast = k; fast < size; ++fast) {
if (nums[slow - k] != nums[fast]) {
nums[slow++] = nums[fast];
}
}
return slow;
}
};
长度不超过 2 的数组直接返回,已经涵盖空数组,因此无需额外的空数组判断。
由于 slow 始终表示"下一个写入位置",循环结束后,它本身就是有效元素数量,直接返回即可。
复杂度分析:
- 时间复杂度:
O(n)。
- 空间复杂度:
O(1)。
相比分段计数法,这种写法不需要 idx 和 cnt,判断条件也直接对应题目的"最多保留两个"。
三、优化第一题
第一题最初的写法中,slow 指向最后一个有效元素;第二种通用写法中,slow 指向下一个写入位置。
后一种定义更容易扩展到"最多保留 k 个",因此可以用它重写第一题。
第一题相当于 k = 1:第一个元素直接保留,slow 和 fast 都从下标 1 开始。每次将当前候选值与结果区最后一个元素 nums[slow - 1] 比较,不同就写入。
cpp
k = 1 → 比较 nums[fast] 与 nums[slow - 1]

优化后的代码如下:
cpp
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
if (nums.empty()) return 0;
int slow = 1;
for (int fast = 1; fast < nums.size(); ++fast) {
if (nums[slow - 1] != nums[fast]) {
nums[slow++] = nums[fast];
}
}
return slow;
}
};
次优化并没有改变时间和空间复杂度,提升的是指针语义的一致性与代码的可推广性 。原优化代码里的 k = 1 没有参与运算,因此最终代码将其移除。
令 k ≥ 1 表示每个元素最多保留的个数。前 k 个元素直接保留;从后续元素开始,将候选值与结果区中 slow - k 位置的元素比较。
代码:
cpp
int removeDuplicates(vector<int>& nums, int k) {
int n = nums.size();
if (n <= k) return n;
int slow = k;
for (int fast = k; fast < n; ++fast) {
if (nums[fast] != nums[slow - k]) {
nums[slow++] = nums[fast];
}
}
return slow;
}
两道题都可以由这份模板得到:
- 第一题:每个元素最多保留 1 个,即
k = 1。
- 第二题:每个元素最多保留 2 个,即
k = 2。
四、总结
从第一题到第二题,真正需要变化的不是双指针框架,而是"允许保留多少重复元素"的判断条件。
快指针负责"看候选",慢指针负责"管结果";能否保留当前元素,由结果区中
slow - k位置的元素决定。
先掌握只留一个的基本扫描过程,再理解分段计数法,最后抽象出 slow - k 的通用判断,就完成了从具体实现到通用模型的过渡。