c++ unique() distance() 删除数组重复元素

• 问题引入：

给定一个排好序的数组，删除重复元素，使每个元素至多出现一次。下面一个例子，不用返回数组，返回修改后的数组长度。

输入：{1，2，3，3，4}
输出：4， 为{1，2，3，4}

如果是 {1，2，3，4，4，1}
我们可以将 先排序，然后在进行此方法。

• 解法1：双指针解法，设置一快一慢的指针，来解决此问题。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int len = nums.size();

        if (len == 0) return 0;

        int index = 0;
        for (int i = 1; i < len; i++) {
            if (nums[index] != nums[i]) {
                nums[++index] = nums[i];
            }
        }
        return index + 1;
    }
};

• 解法二：利用STL库函数 unique 和 distance

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

因为distance 求的是两个迭代器之间的元素个数，因此我们在做连续空间时候，指针连续，也可以直接相减。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        auto it = unique(nums.begin(), nums.end());
        return it - nums.begin();
    }
};

• 问题升级，删除重复元素，最多可以有两个。此解法可以做为一个模板，删除最多的元素，最多留几个。。也可以用map去记录每个出现的个数，空间复杂度就高了。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int len = nums.size();

        if (len <= 2) return len;
        
        int index = 2;
        for (int i = 2; i < len; i++) {
            if (nums[i] != nums[index-2]) {
                nums[index++] = nums[i];
            }
        }

        return index;
    }
};

 以上面的模板，解决问题一。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int len = nums.size();

        if (len == 0) return 0;
        
        int index = 1;
        for (int i = 1; i < len; i++) {
            if (nums[i] != nums[index-1]) {
                nums[index++] = nums[i];
            }
        }

        return index;
    }
};

• unique() 函数， 在 <algorithm> 库里面。从范围内的每个连续的等效元素组中除去除第一个元素外的所有元素[first,last)。在移除重复元素后，它会返回一个正向迭代器作为新序列的结束迭代器。 不连续的不会删除。不仅可以处理数字，也可以处理字符串。查看此

  // unique algorithm example
  #include <iostream>     // std::cout
  #include <algorithm>    // std::unique, std::distance
  #include <vector>       // std::vector
  
  bool myfunction (int i, int j) {
    return (i==j);
  }
  
  int main () {
    int myints[] = {10,20,20,20,30,30,20,20,10};           // 10 20 20 20 30 30 20 20 10
    std::vector<int> myvector (myints,myints+9);
  
    // using default comparison:
    std::vector<int>::iterator it;
    it = std::unique (myvector.begin(), myvector.end());   // 10 20 30 20 10 ?  ?  ?  ?
                                                           //                ^
  
    myvector.resize( std::distance(myvector.begin(),it) ); // 10 20 30 20 10
  
    // using predicate comparison:
    std::unique (myvector.begin(), myvector.end(), myfunction);   // (no changes)
  
    // print out content:
    std::cout << "myvector contains:";
    for (it=myvector.begin(); it!=myvector.end(); ++it)
      std::cout << ' ' << *it;
    std::cout << '\n';
  
    return 0;
  }
  
  //输出：myvector contains: 10 20 30 20 10

•  distance() 函数定义在<iterator>头文件，并位于 std 命名空间中。 如果是连续空间，指针直接相减就可以得到元素个数，如果是链表的话，需要一个一个往后比较。然后统计个数。

If it is a random-access iterator, the function uses operator- to calculate this. Otherwise, the function uses the increase operator (operator++) repeatedly.

#include <iostream>     // std::cout
#include <iterator>     // std::distance
#include <list>         // std::list
using namespace std;

int main() {
    //创建一个空 list 容器
    list<int> mylist;
    //向空 list 容器中添加元素 0~9
    for (int i = 0; i < 10; i++) {
        mylist.push_back(i);
    }
    //指定 2 个双向迭代器，用于执行某个区间
    list<int>::iterator first = mylist.begin();//指向元素 0
    list<int>::iterator last = mylist.end();//指向元素 9 之后的位置
    //获取 [first,last) 范围内包含元素的个数
    cout << "distance() = " << distance(first, last);
    return 0;
}

//输出 distance() = 10