如何有效地从给定另一个向量的向量中删除元素

我的版本如下，我只在向量vSource的所有元素被std::remove移动到末尾后应用erase，并跟踪指向向量vDestination末尾的指针，而不是一无所获地迭代它。

void remove_elements(vector<int>& vDestination, const vector<int>& vSource) 
{
    auto last = std::end(vDestination);
    std::for_each(std::begin(vSource), std::end(vSource), [&](const int & val) {
        last = std::remove(std::begin(vDestination), last, val);
    });
    vDestination.erase(last, std::end(vDestination));
}

参见coliru: http://coliru.stacked-crooked.com/a/6e86893babb6759c

这是一个模板版本，所以你不关心容器类型:

template <class ContainerA, class ContainerB>
void remove_elements(ContainerA & vDestination, const ContainerB & vSource) 
{
    auto last = std::end(vDestination);
    std::for_each(std::begin(vSource), std::end(vSource), [&](typename ContainerB::const_reference val) {
        last = std::remove(std::begin(vDestination), last, val);
    });
    vDestination.erase(last, std::end(vDestination));
}

注意

这个版本适用于没有任何约束的向量，如果你的向量是排序的，你可以采取一些快捷方式，避免迭代遍历向量来删除每个元素。

我认为你所说的最好的是指最快的。由于这是一个关于效率的问题，我执行了一个简单的基准来比较几种算法的效率。请注意，它们有一点不同，因为问题有点不明确—出现的问题(以及基准测试的假设)如下:

• 是否保证vDestination包含vSource的所有元素?(假设:没有)
• 在vDestination或vSource中允许重复吗?(假设:是的，在两个)
• 结果向量中元素的顺序是否重要?(测试两种情况的算法)
如果vDestination中的每个元素与vSource中的任何元素相等，或者只是一对一的，那么应该删除它们吗?(假设:是的，在两个)
• vDestination和vSource的大小是有界的吗?它们中的一个总是更大还是大得多?(已测试的几个案例)
• 在评论中已经解释了向量不需要排序，但我已经包括了这一点，因为它不是立即从问题中可见(没有排序假设在两个向量中)

1. 原始
-基线@dkg回答中提出的
3. 在@Revolver_Ocelot答案中提出+额外排序(算法要求)和结果的预预留空间向量
4. 在@Jarod42回答中提出
5. 基于集合的算法(如下所示-主要是@Jarod42算法的优化)
6. 计数算法(见下文)

基于集合的算法:

std::unordered_set<int> elems(vSource.begin(), vSource.end());
auto i = destination.begin();
auto target = destination.end();
while(i <= target) {
    if(elems.count(*i) > 0) 
        std::swap(*i, *(--target));
    else
        i++;
}
destination.erase(target, destination.end());

计数算法:

std::unordered_map<int, int> counts;     
counts.max_load_factor(0.3);     
counts.reserve(destination.size());      
for(auto v: destination) {     
    counts[v]++;     
}     
for(auto v: source) {     
    counts[v]--;     
}     
auto i = destination.begin();     
for(auto k: counts) {     
    if(k.second < 1) continue;            
    i = std::fill_n(i, k.second, k.first);     
}     
destination.resize(std::distance(destination.begin(), i));     

使用Celero库执行基准测试过程，如下所示:

1. 生成n伪随机int s (n在{10,100,1000,10000, 20000, 200000}集合中)并将它们放入vector
2. 复制一个分数(m)到第二个vector(分数从set {0.01, 0.1, 0.2, 0.4, 0.6, 0.8}, min. 1元素)
3. 开始定时器
4. 执行删除程序
5. 停止计时器

只有算法3、5和6在大于10,000个元素的数据集上执行，因为其余的算法需要很长时间才能让我舒服地测量(请随意自己做)。

长话短说:如果你的向量包含少于1000个元素，选择你喜欢的。如果它们更长-依赖于vSource的大小。如果小于vDestination的50% -选择基于集合的算法，如果大于-对它们进行排序并选择@Revolver_Ocelot的解决方案(它们在60%左右，当vSource的大小为vDestination的1%时，基于集合的速度超过2倍)。请不要依赖于顺序或提供一个从一开始就排序的向量——要求顺序必须保持不变会大大降低过程的速度。对你的用例、编译器、标志和硬件进行基准测试。我附上了我的基准测试的链接，以防你想复制它们。

完整的结果(文件vector-benchmarks.csv)可在GitHub上与基准测试代码(文件tests/benchmarks/vectorRemoval.cpp)一起获得。

请记住，这些是我在我的计算机上获得的结果，我的编译器等-在你的情况下，它们会有所不同(特别是当涉及到一个算法比另一个更好的点时)。

我在Fedora 24上使用了GCC 6.1.1和-O3，在VirtualBox之上。

如果你的向量总是排序的，你可以使用set_difference:

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
void remove_elements(std::vector<int>& vDestination, const std::vector<int>& vSource) 
{
    std::vector<int> result;
    std::set_difference(vDestination.begin(), vDestination.end(), vSource.begin(), vSource.end(), std::back_inserter(result));
    vDestination.swap(result);
}
int main() 
{
    std::vector<int> v1={1,2,3};
    std::vector<int> v2={4,5,6};
    std::vector<int> v3={1,2,3,4,5,6,7,8,9};
    remove_elements(v3,v1);
    remove_elements(v3,v2);
    for(auto i:v3)
        std::cout << i << 'n';
}

如果不需要，输出范围不应该与任何输入范围重叠，我们甚至可以避免额外的向量。您可以使用自己的set_difference版本，允许在从vDestination.begin()开始的范围内输出，但它超出了这个答案的范围。

可以用STL写成:

void remove_elements(vector<int>& vDestination, const vector<int>& vSource) 
{
    const auto isInSource = [&](int e) {
        return std::find(vSource.begin(), vSource.end(), e) != vSource.end();
    };
    vDestination.erase(
        std::remove_if(vDestination.begin(), vDestination.end(), isInSource),
        vDestination.end());
}

如果vSource已排序，则可以将std::find替换为std::binary_search