【数组、容器】26. 删除排序数组中的重复项

---

一、题

题目

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

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

示例

• 示例 1:

给定数组 nums = [1,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。

你不需要考虑数组中超出新长度后面的元素。

---

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、题意误解

• 执行时间：自己原来写的代码执行时间132ms，10.2M，是最优解仅20多ms。

• 思路：擦除erase()
  用一个栈记录多余数的下标，因为数组是已经排好序的数组，所以数组中的多余数就可以通过判断后者等于前者得到，然后通过vector的erase()函数从后往前擦出多余的数（只要保证下标的相对位置不变就行，我是用nums.begin()为参考点，所以从后往前，反之nums.end()）

• 优化思路：
  \quad 题中的条件越多，那么这个题就越好做。所以优化思路就在我们没有用到的条件“你不需要考虑数组中超出新长度后面的元素。”意思是我们并不需要像我解一样得到一个完美的没有多余长度的解，只要得到想要的特定部分就Ok。
  \quad 擦除太费劲了，需要重置容器。赋值改变才是王道。

原生版：使用栈

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        
        //处理空数组
        if(nums.size()==0) return 0;
        
        //存储多余数的下标的栈
        stack<int> s;
        
        //记录多余的数的下标
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]==nums[i-1])
            {
                s.push(i);
            }
        }
        
        //擦除多余的数
        while(s.size())
        {
            vector<int>::iterator l=nums.begin();
            nums.erase(l+s.top());
            s.pop();
        }
        return nums.size();
    }
};

改进版：把栈的功能代替，没想到耗时更长264ms。用擦除的思路是死了。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        
        //处理空数组
        if(nums.size()==0) return 0;
        
        int size=nums.size();
        
        //i记录多余的数的下标，k表式要从头到尾判断所有元素所需的次数，
        for(int i=1,k=1;k<size;k++)
        {
        	//擦除后i下标处的元素被更新，需要再次比较新元素，所以i不变
            if(nums[i]==nums[i-1])
            {
                nums.erase(nums.begin()+i);
            }
            //不擦除就判断下一个元素
            else	
            {
                i++;
            }
        }
        
        return nums.size();
    }
};

三、最优解

赋值操作果然比大幅改动容器的erase()

• 解法：这下面两个解法其实思路一样，都是用一个变量move/len记录从0开始要赋值的下标。

• 等于解法：其实i-move等于len。赋值操作nums[i-move] = nums[i];每次循环执行一次，当nums[i]==nums[i-1]时，move和i的值同步增加，所以i-move的值不变，因为nums的前后两个值相同，所以要赋值的下标的值不变。而当前后值不同时，move值不变，而i的值增加，所以i-move要赋值的下标后移一格，赋上新的不同的值。

• 不等于解法：判断nums[i]和nums[len-1]的值，所以如果不相等的话，那么将nums[len]的值赋上nums[i]的值，然后len++。注意下标是len-1，而赋值时的下标是len，len初始是1。这个的意思是len表示不重复的元素的个数，所以答案return len，而要得到新元素时，下标正好和个数差1，所以新元素的下标用个数就ok，nums[len]，然后因得到了新的不重复的元素，len++。

1.等于

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int move = 0;
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]==nums[i-1])
                move++;
            nums[i-move] = nums[i];
        }
        return nums.size()-move;
    }
};

2.不等于

class Solution {
public:
    int removeDuplicates(vector<int>& nums) 
    {
        if(nums.size()==0)
            return 0;
        int len=1;
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]!=nums[len-1])
            {
                nums[len]=nums[i];
                len++;
            }    
        }
        return len;
    }
};

魔改一下，同一原理：
我们使用len作为下标，初始值为0，所以得到新的元素，那么它的下标就是len+1。答案是要个数，所以下标+1，return len+1。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) 
    {
        if(nums.size()==0)
            return 0;
        int len=0;
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]!=nums[len])
            {
                nums[len+1]=nums[i];
                len++;
            }    
        }
        return len+1;
    }
};