力扣解题-80. 删除有序数组中的重复项 II

力扣解题-80. 删除有序数组中的重复项 II

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明： 为什么返回数值是整数，但输出的答案是数组呢？ 请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1： 输入：nums = [1,1,1,2,2,3] 输出：5, nums = [1,1,2,2,3] 解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。

示例 2： 输入：nums = [0,0,1,1,1,1,2,3,3] 输出：7, nums = [0,0,1,1,2,3,3] 解释：函数应返回新长度 length = 7, 并且原数组的前七个元素被修改为 0, 0, 1, 1, 2, 3, 3。不需要考虑数组中超出新长度后面的元素。

提示：

1 <= nums.length <= 3 * 104

-104 <= nums[i] <= 104

nums 已按升序排列

---

官方解答

解题思路

核心方法：快慢双指针（基于相邻对比的次数限制），在“删除有序数组重复项（保留1次）”的双指针思路基础上升级，利用数组“升序排列，重复元素连续”的特性，通过快慢指针控制元素最多保留两次，时间复杂度O(n)、空间复杂度O(1)，是本题的最优解法。

核心原理铺垫

数组升序排列 → 重复元素必然连续出现，要实现“最多保留两次”，核心判断逻辑为：若当前元素与前一个元素不同，则必然是新元素，可保留；若相同，则说明是第三次及以上重复，需跳过（注：该逻辑是官方解法的核心简化版，适配题目要求的“最多两次”）。

• 慢指针（slow）：记录“下一个可写入元素的位置”，初始为2（前两个元素无论是否重复，都可直接保留，无需处理）；
• 快指针（fast）：遍历数组，检查每个元素是否符合“最多保留两次”的条件，初始为2（从第三个元素开始检查）。

具体步骤

1. 边界处理：获取数组长度n = nums.length，若n <= 2，直接返回n（数组长度≤2时，所有元素天然满足“最多两次”的要求，无需处理）；
2. 初始化双指针：
   • slow = 2：前两个元素（nums[0]、nums[1]）默认保留，慢指针从第三个位置开始写入；
   • fast = 2：从第三个元素开始遍历检查。
3. 快指针遍历数组（while(fast < n)）：
   • 核心判断：nums[fast] != nums[fast-1]（当前元素与前一个元素不同，说明不是连续第三次及以上重复，可保留）；
   • 若满足条件：将nums[fast]写入慢指针位置nums[slow]，慢指针右移一位（slow++）；
   • 无论是否满足条件，快指针均右移一位（fast++），继续检查下一个元素。
4. 返回结果：遍历完成后，slow的值即为处理后数组的新长度（慢指针的位置等于已写入的符合条件的元素个数）。

核心优化逻辑说明

1. 时间复杂度最优：仅一次遍历数组（O(n)），每个元素仅被快指针访问一次，无嵌套循环或冗余计算，因此耗时0ms击败100%用户；
2. 空间复杂度极致：仅使用两个指针变量，无额外数组/集合创建，完全满足题目“O(1)额外空间”的要求；
3. 逻辑适配题目核心要求：
   • 利用“升序数组重复元素连续”的特性，通过相邻元素对比简化“次数判断”，无需额外计数变量；
   • 慢指针仅写入符合条件的元素，保证前slow个元素满足“最多两次重复”，且保持原数组的相对顺序；
4. 内存表现说明：内存消耗47.8MB击败75.24%用户，是因为仅使用基础变量，无任何额外存储开销，已达到理论最优（O(1)），差异仅来自评测机环境。

补充说明：官方解法的核心判断逻辑可进一步严谨化为 nums[fast] != nums[slow-2]（判断当前元素与慢指针前两位元素是否相同，避免超过两次重复），两种逻辑均正确，前者是简化版，后者是更通用的“保留k次”模板（k=2时），最终性能一致。

执行耗时:0 ms,击败了100.00% 的Java用户 内存消耗:47.8 MB,击败了75.24% 的Java用户

    public int removeDuplicates(int[] nums) {
        int n=nums.length;
        int slow=2;
        int fast=2;
        while(fast<n){
            if(nums[fast]!=nums[fast-1]){
                nums[slow]=nums[fast];
                slow++;
            }
            fast++;
        }
        return slow;
    }

---

总结

1. 该解法的核心是双指针的升级适配：在“保留1次重复”的双指针基础上，将慢指针初始位置设为2，利用相邻对比实现“最多保留两次”的限制；
2. 关键技巧是利用有序数组的特性简化判断：无需额外计数，仅通过相邻元素对比即可判断是否超出重复次数，大幅简化逻辑；
3. 本题的通用扩展思路：若要求“最多保留k次”，可将慢指针初始化为k，判断条件改为nums[fast] != nums[slow-k]，即可适配任意k值的重复次数限制。