效率是一个复杂的概念。有时间和空间的考虑，以及一般的测量(你只能得到模糊的答案，如O(n))和特定的(例如冒泡排序可以比快速排序快得多，这取决于输入特征)。

如果你有相对较少的副本，那么排序，然后唯一和擦除似乎是要走的路。如果您有相对较多的副本，则从向量创建一个集合，并让它完成繁重的工作，可以轻松击败它。

也不要只关注时间效率。Sort+unique+erase操作在O(1)空间，而set构造操作在O(n)空间。而且这两种方法都不能直接用于map-reduce并行化(对于真正庞大的数据集)。

更多可理解的代码来自:https://en.cppreference.com/w/cpp/algorithm/unique

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cctype>

int main() 
{
    // remove duplicate elements
    std::vector<int> v{1,2,3,1,2,3,3,4,5,4,5,6,7};
    std::sort(v.begin(), v.end()); // 1 1 2 2 3 3 3 4 4 5 5 6 7 
    auto last = std::unique(v.begin(), v.end());
    // v now holds {1 2 3 4 5 6 7 x x x x x x}, where 'x' is indeterminate
    v.erase(last, v.end()); 
    for (int i : v)
      std::cout << i << " ";
    std::cout << "\n";
}

增长:

1 2 3 4 5 6 7

我同意R. Pate和Todd Gardner的观点;std::set在这里可能是个好主意。即使你在使用向量时遇到了困难，如果你有足够多的副本，你最好创建一个集合来做这些肮脏的工作。

让我们来比较三种方法:

用向量，sort + unique

sort( vec.begin(), vec.end() );
vec.erase( unique( vec.begin(), vec.end() ), vec.end() );

转换为set(手动)

set<int> s;
unsigned size = vec.size();
for( unsigned i = 0; i < size; ++i ) s.insert( vec[i] );
vec.assign( s.begin(), s.end() );

转换为set(使用构造函数)

set<int> s( vec.begin(), vec.end() );
vec.assign( s.begin(), s.end() );

下面是它们在重复数量变化时的表现:

总结:当副本的数量足够大时，实际上更快地将数据转换为一个集合，然后将数据转储回一个向量。

出于某种原因，手动进行set转换似乎比使用set构造函数更快——至少在我使用的随机数据上是这样。

我重做了内特·科尔的侧写得到了不同的结果。对于我的测试用例，直接对向量排序总是比使用集合更有效。我添加了一个新的更有效的方法，使用unordered_set。

请记住，unordered_set方法仅适用于您需要唯一和排序的类型的良好哈希函数。对于int型，这很简单!(标准库提供了一个默认的哈希，它只是标识函数。)另外，不要忘记在最后排序，因为unordered_set是无序的:)

我深入研究了set和unordered_set实现，发现构造函数实际上为每个元素构造了一个新节点，然后检查其值以确定是否应该实际插入(至少在Visual Studio实现中是这样)。

以下是5种方法:

f1:只是使用向量，sort + unique

sort( vec.begin(), vec.end() );
vec.erase( unique( vec.begin(), vec.end() ), vec.end() );

f2:转换为set(使用构造函数)

set<int> s( vec.begin(), vec.end() );
vec.assign( s.begin(), s.end() );

f3:转换为set(手动)

set<int> s;
for (int i : vec)
    s.insert(i);
vec.assign( s.begin(), s.end() );

f4:转换为unordered_set(使用构造函数)

unordered_set<int> s( vec.begin(), vec.end() );
vec.assign( s.begin(), s.end() );
sort( vec.begin(), vec.end() );

f5:转换为unordered_set(手动)

unordered_set<int> s;
for (int i : vec)
    s.insert(i);
vec.assign( s.begin(), s.end() );
sort( vec.begin(), vec.end() );

我在[1,10]，[1,1000]和[1,100000]的范围内随机选择了100,000,000 int的向量进行测试

结果(以秒为单位，越小越好):

range         f1       f2       f3       f4      f5
[1,10]      1.6821   7.6804   2.8232   6.2634  0.7980
[1,1000]    5.0773  13.3658   8.2235   7.6884  1.9861
[1,100000]  8.7955  32.1148  26.5485  13.3278  3.9822

unique只适用于重复元素的连续运行，所以你最好先排序。但是，它是稳定的，所以你的向量是有序的。

关于alexK7基准测试。我尝试了它们，得到了类似的结果，但是当值的范围为100万时，使用std::sort (f1)和使用std::unordered_set (f5)的情况产生类似的时间。当取值范围为1000万时，f1比f5快。

如果值的范围是有限的，并且值是无符号int，则可以使用std::vector，其大小对应于给定的范围。代码如下:

void DeleteDuplicates_vector_bool(std::vector<unsigned>& v, unsigned range_size)
{
    std::vector<bool> v1(range_size);
    for (auto& x: v)
    {
       v1[x] = true;    
    }
    v.clear();

    unsigned count = 0;
    for (auto& x: v1)
    {
        if (x)
        {
            v.push_back(count);
        }
        ++count;
    }
}