[LeetCode] 26、80.删除有序数组中的重复项 题解

一、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] <= 100
  • nums 已按 非递减 顺序排列。

总结一下,题目要求就是给定一个按非递减顺序排列的数组,原地删除重复元素,使每个元素只出现一次,并返回处理后的数组长度。返回值之后的内容不需要关心。

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 的通用判断,就完成了从具体实现到通用模型的过渡。

相关推荐
forest_0912 小时前
《AI 编程 Harness 实战手册》04|审批这道门:点了一百次“允许”,还剩多少作用?
人工智能·算法·prompt·agi
H.莓飛12 小时前
【C++】【STL】stack_OJ题
服务器·c语言·开发语言·数据结构·c++·算法·visual studio
不会武功不懂江湖14 小时前
RISC-V链接器与链接脚本
汇编·算法·risc-v
Zwawa15 小时前
卡尔曼到底在算什么:从一维到它的变式以及工程版卡尔曼滤波算法C语言实现
c语言·算法·嵌入式
电科_银尘15 小时前
【大模型算法与工程 14】Tokenizer与Embedding:文本如何变成模型输入
算法·embedding
饮水桶_T16 小时前
Python 面向对象(十七)|继承、封装、多态 笔记
数据结构·笔记·算法
地平线开发者20 小时前
让 AI Agent 和 征程6 台架高效、稳定、安全地协作
算法·安全·自动驾驶
kyle~20 小时前
SHA-256 哈希去重
算法·哈希算法