【leetcode】删除排序数组中的重复项（多种解法）

我是在努力的刷leetcode题的时候，无意中发现我这个题已经提交了好多次，但是我发现每一次自己的写法或者想法不太一样，所以我就总结出来我每次写的方法，也希望大家以后在刷题的过程中，可以集思广益，考虑多种不同的解法。或者同一种方法但是不同的写法带来的坑（比如此篇的方法二和四）

删除排序数组中的重复项之四种解法

题目描述：
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 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。

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

方法一： 通过库函数erase()删除

【算法思想】： 因为已经有一个大前提就是数组是排序数组， 那么通过算法库（#include < algorithm >）中的erase函数和 vector库中的 unique函数来完成去重的过程 也是非常简便的算法，仅仅两行，哈哈

【优缺点分析】：

1. 调用erase函数性能会降低很多，毕竟erase释放一段空间的时间复杂度为O(n) 。
2. 在排好序之后(题目已给出)，unique函数只是将重复的元素放置到数组的后面，然后返回的迭代器指向第一个重复元素的位置，通过两指针排序的算法复杂度也是O(n)

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        nums.erase(unique(nums.begin(),nums.end()),nums.end());
        return nums.size();
    }
};

方法二： 通过快慢指针

【算法思想】：在原数组中，定义两个变量i , j 来标识数组下标 ，一个变量 j 作为新的nums数组的下标，将另一变量 i 遍历数组， 如果与 nums[j] 不相同， 就在原数组上覆盖j的下一个位置， 直到i遍历完数组，返回下标 j 的下一个位置， 就是新的无重复数组的大小。

【优缺点分析】：

1. 时间复杂度为O(n) , 因为遍历了整个数组。
2. 空间复杂度为O(1), 因为在原数组上操作，只是将数据进行了覆盖

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

方法三：覆盖重复项

【算法思想】：通过快慢指针start和end，两个指针只差一个身位。 如果指向的数据相同，后面的其余数据进行覆盖。
1. 需要注意的是如果进行覆盖之后，start和end就不需要进行向后++了， 因为start指向的位置不变，end指向覆盖过来的新数据，位置也不变。(有可能出现3或多个数据一起的情况)。 所以要–，然后在while循环后在进行++，保持两个指针指向的位置不变
2. 需要注意的是，每进行一次覆盖，就要将最后的位置进行释放，最终要返回nums的大小。

【优缺点分析】：

1. 时间复杂度为O(n*n) , 因为遍历了整个数组,而且还有后面的数据进行覆盖
2. 空间复杂度为O(1), 因为在原数组上操作。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.empty()|| nums.size()==1)
        {
            return nums.size();
        }
        int start = 0;
        int end = 1;
        while(end < nums.size())
        {
            if(nums[start] == nums[end])// 0 1 1 1
            {
                for(int i = end; i < nums.size()-1; i ++)
                {
                    nums[i] = nums[i+1];
                }
                nums.erase(--nums.end());
                start-=1;
                end-=1;
            }
            start++;
            end++;
        }
        return nums.size();
    }
};

方法四：快慢指针（需要注意边界情况）

【算法思想】：和方法二类似，但是还是有些不同，通过快慢指针prev和cur，比较，不同的话，进行原数组的覆盖（通过下标curId控制）。但是不同的一点就是当快指针走到最后一个元素的下标时，一定要进行覆盖，也就是新的nums中。如果没有的话，因为遇到 1 1 2 的情况，当prev=1，cur为2时，nums[prev] != nums[cur], nums[prev]进行原数组的覆盖， 新覆盖得到数组只有{1}，没有 2 。

【优缺点分析】：

1. 时间复杂度为O(n) , 因为遍历了整个数组
2. 空间复杂度为O(1), 因为在原数组上操作。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.empty() || nums.size() == 1)
            return nums.size();
        int prev = 0;
        int cur = 1;
        int curId = 0;
        while(cur < nums.size()) //  0 1 1
        {
            if(nums[prev] != nums[cur])
            {
                nums[curId++] = nums[prev];
            }
            if(cur == nums.size()-1)
                    nums[curId++] = nums[cur];
            
            prev++;
            cur++;
        }
        return curId;
    }
};