我需要对一个可能有很多元素的C++向量进行去重并排序。
我目前有下面的代码，但它不起作用。
vec.erase(
std::unique(vec.begin(), vec.end()),
vec.end());
std::sort(vec.begin(), vec.end());
如何正确地执行此操作?
另外，先删除重复项(类似上面的代码)还是先进行排序更快？如果我先进行排序，执行std::unique后是否保证仍然排序？
或者还有其他（可能更有效的）方法来完成所有这些操作吗？
我同意R. Pate和Todd Gardner的看法: 在这里使用 std::set 可能是个好主意。即使你被迫使用向量(vector)，如果有足够多的重复项，创建一个集合(set)来完成繁重的工作可能会更有效。
现在我们比较三种方法:
只使用向量(vector)，sort + unique
sort( vec.begin(), vec.end() );
vec.erase( unique( vec.begin(), vec.end() ), vec.end() );
手动转换为集合
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<int> s( vec.begin(), vec.end() );
vec.assign( s.begin(), s.end() );
以下是这些方法在重复项数量变化时的性能表现：
概括：当重复项的数量足够大时，将数据转换为集合再转回向量实际上更快。
出于某种原因，在使用我使用的随机数据时，手动执行集合转换似乎比使用集合构造函数更快。
我重新做了Nate Kohl的分析并得到不同的结果。对于我的测试案例，直接对向量进行排序始终比使用集合更有效率。我添加了一个新的更高效的方法，使用 unordered_set。
请记住，unordered_set 方法仅在您拥有适用于需要去重和排序的类型的良好哈希函数时才有效。对于整数，这很容易！（标准库提供了一个默认哈希，即恒等函数。）此外，不要忘记在最后进行排序，因为无序集合是无序的：）
我深入研究了 set 和 unordered_set 的实现，并发现构造函数实际上会为每个元素构造一个新的节点，然后检查其值以确定是否应将其插入（至少在 Visual Studio 实现中如此）。
以下是5种方法：
f1: 只使用 vector，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亿个int类型的向量进行了测试，这些整数是在区间[1,10]、[1,1000]和[1,100000]中随机选择的。
结果如下（时间以秒为单位，数字越小表示速度越快）：
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
sort或unique方法，您必须#include <algorithm>。 - Davmrtlstd::unique只会移除相邻的重复元素: 你需要先对向量进行排序，才能按照你的意图运行它。
std::unique被定义为稳定的，因此在对其运行 unique 后，向量仍将保持排序状态。
我不确定您将用它用于什么，因此我不能以100%的确切性说出，但通常当我想到“排序、唯一”的容器时，我会想到std::set。它可能更适合您的用例：
std::set<Foo> foos(vec.begin(), vec.end()); // both sorted & unique already
std::unique 只适用于连续重复的元素，因此最好先进行排序。然而，它是稳定的，所以你的向量将保持已排序状态。
这是一个为你解决问题的模板：
template<typename T>
void removeDuplicates(std::vector<T>& vec)
{
std::sort(vec.begin(), vec.end());
vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
}
按以下方式调用：
removeDuplicates<int>(vectorname);
erase() 方法的其他容器，否则您必须返回新的结束迭代器，并让调用代码截断容器。 - Toby Speighttemplate <class T>
void RemoveDuplicatesInVector(std::vector<T> & vec)
{
set<T> values;
vec.erase(std::remove_if(vec.begin(), vec.end(), [&](const T & value) { return !values.insert(value).second; }), vec.end());
}
std::ranges::remove_if的pred受到std::indirect_binary_predicate的限制，该限制包含了std::predicate，其组件regular_invocable“_要求[它...]是保持相等性的_” - &根据values等状态，使其不能保持相等性。我认为旧的remove_if也是如此。 - underscore_da.erase(unique(a.begin(),a.end()),a.end()); 可以删除其中任何连续的重复元素，该操作的时间复杂度为O(n)。std::sort 排序。 - v.oddou效率是一个复杂的概念。存在时间与空间考虑，以及一般测量（其中您只会得到模糊的答案，例如O(n)）与具体测量（例如，根据输入特征，冒泡排序可能比快排快得多）。
如果您有相对较少的重复项，则排序后跟随唯一和擦除似乎是正确的选择。如果您有相对较多的重复项，则从向量创建集并让其执行操作可以轻松击败它。
不要只专注于时间效率。排序+唯一+擦除在O(1)空间中运行，而集合构建在O(n)空间中运行。两者都不直接适用于映射-归约并行化（针对真正巨大的数据集）。