题目

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

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

代码

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

    }
}

代码解释

public int removeDuplicates(int[] nums) {
    int n = nums.length;  // 获取数组长度
    if (n <= 2) {
        return n;  // 如果数组长度小于等于2，直接返回长度，因为最多出现两次是允许的
    }
    int slow = 2;  // 初始化慢指针，指向位置2（第3个元素）
    int fast = 2;  // 初始化快指针，也指向位置2
    while (fast < n) {  // 开始遍历数组
        if (nums[slow - 2] != nums[fast]) {  // 比较当前慢指针前两个位置的元素和快指针的元素
            nums[slow] = nums[fast];  // 如果不同，更新慢指针位置的元素
            ++slow;  // 慢指针前移
        }
        ++fast;  // 快指针前移
    }
    return slow;  // 返回新数组的长度
}

例子

假设输入数组为 nums = [1, 1, 1, 2, 2, 3]。

1. 初始状态:

   • nums = [1, 1, 1, 2, 2, 3]
   • slow = 2
   • fast = 2

2. 第一次循环 (fast = 2):

   • nums[slow - 2] = nums[0] = 1
   • nums[fast] = nums[2] = 1
   • 因为 nums[slow - 2] == nums[fast]，所以 fast 前移。
   • fast = 3

3. 第二次循环 (fast = 3):

   • nums[slow - 2] = nums[0] = 1
   • nums[fast] = nums[3] = 2
   • 因为 nums[slow - 2] != nums[fast]，更新 nums[slow] = nums[fast]
   • nums = [1, 1, 2, 2, 2, 3]
   • slow 前移，slow = 3
   • fast 前移，fast = 4

4. 第三次循环 (fast = 4):

   • nums[slow - 2] = nums[1] = 1
   • nums[fast] = nums[4] = 2
   • 因为 nums[slow - 2] != nums[fast]，更新 nums[slow] = nums[fast]
   • nums = [1, 1, 2, 2, 2, 3]（值不变）
   • slow 前移，slow = 4
   • fast 前移，fast = 5

5. 第四次循环 (fast = 5):

   • nums[slow - 2] = nums[2] = 2
   • nums[fast] = nums[5] = 3
   • 因为 nums[slow - 2] != nums[fast]，更新 nums[slow] = nums[fast]
   • nums = [1, 1, 2, 2, 3, 3]
   • slow 前移，slow = 5
   • fast 前移，fast = 6

6. 循环结束 (fast = 6):

   • 因为 fast 到达数组末尾，循环结束。

最后，slow 的值为 5，这就是新数组的长度。新数组内容为 [1, 1, 2, 2, 3]。

这样，代码确保了每个元素最多只出现两次，并返回了处理后的数组长度。