[LeetCode] 80. Remove Duplicates from Sorted Array II

原题链接：https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/

1. 题目介绍

Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.
Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

给出一个有序数组nums，如果其中包括重复次数超过2次的元素，对这些元素只保留2个，其余的都删除。
不能使用额外的数组空间，只能在原数组的基础上修改。空间复杂度为O（1）。

Example 1:

Given nums = [1,1,1,2,2,3],
Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.
It doesn’t matter what you leave beyond the returned length.
给出数组nums = [1,1,1,2,2,3],
你的函数需要返回length = 5，前五个元素是1，1，2，2，3
数组中，前5个元素之后的其他元素是多少无所谓。
Example 2:

Given nums = [0,0,1,1,1,1,2,3,3],
Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.
It doesn’t matter what values are set beyond the returned length.
给出数组nums = [0,0,1,1,1,1,2,3,3],
你的函数需要返回length = 7，前7个元素是0，0，1，1，2，3，3
数组中，前7个元素之后的其他元素是多少无所谓。

Clarification:

Confused why the returned value is an integer but your answer is an array?
Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well.
为什么返回值是一个整数，但是你的答案是一个数组？
输入的数组是引用传递的，这意味着，对于输入数组的改变，对于调用者也是可见的。在我们写的函数中修改了数组的值，等到函数调用结束后，这样的修改仍然保留。

Internally you can think of this:
可以参考下面代码：

// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

2. 解题思路

本题可以使用双指针法解决。
难点在于，对于一个元素来说，我们要保留前两个，并且删除后面的多余元素。
如何保留前两个元素呢？

首先，需要明确的一点是，数组是递增有序的。
设定一个左指针left， left之前是任意元素都不超过两个的数组，left之后是未经删除的数组。left的初始值是0.
设定一个右指针 i，i指向当前元素，初始值为0。

对于数组的前两个元素，我们可以不必考虑，无论前两个元素是否相等，我们都不需要删除任何元素。所以，在前两个元素中，left 和 i 始终都是相等的，指向同一个元素。

对于下标大于等于2的元素来说，需要比较 nums[ left-2 ] 和 nums[ i ] 的大小，left 减去 2 ，是为了确保不会出现2个以上的重复。这里的2可以一般化为k，想要保留多少元素，就使用left - k。如果nums[left-2] != nums[i]，那么就将nums[i]的值赋给nums[left]。

时间复杂度： O(n)
空间复杂度：O(1)

实现代码

class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        int left = 0;
        for(int i = 0; i<n ; i++){
            if(left < 2 || nums[left-2] != nums[i]){
                nums[left] = nums[i];
                left ++;
            }
        }
        return left ;
    }
}

如果将问题一般化，在原数组有序排列的基础上，出现次数最多为k次，可以使用如下模板：

class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        int left = 0;
        for(int i = 0; i<n ; i++){
            if(left < k || nums[left-k] != nums[i]){
                nums[left] = nums[i];
                left ++;
            }
        }
        return left ;
    }
}

3. 参考资料

https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array-ii/solution/shan-chu-pai-xu-shu-zu-zhong-de-zhong-fu-xiang-i-2/