Question

我有两个向量，一个是我想要擦除的另一个向量的索引向量。目前我正在做以下事情：

#include <vector>
#include <iostream>
#include <string>

int main() {
        std::vector<std::string> my_vec;
        my_vec.push_back("one");
        my_vec.push_back("two");
        my_vec.push_back("three");
        my_vec.push_back("four");
        my_vec.push_back("five");
        my_vec.push_back("six");

        std::vector<int> remove_these;
        remove_these.push_back(0);
        remove_these.push_back(3);

        // remove the 1st and 4th elements
        my_vec.erase(my_vec.begin() + remove_these[1]);
        my_vec.erase(my_vec.begin() + remove_these[0]);

        my_vec.erase(remove_these.begin(), remove_these.end());

        for (std::vector<std::string>::iterator it = my_vec.begin(); it != my_vec.end(); ++it)
                std::cout << *it << std::endl;

        return 0;
}

但我认为这是不优雅和低效的。此外，我认为我必须小心对remove_these向量进行排序并从结束开始（这就是我在索引0之前擦除索引3的原因）。我想有一个擦除命令，比如

my_vec.erase(remove_these.begin(), remove_these.end());

但当然这不起作用，因为my_vec.erase()期望迭代器引用相同的向量。

Answer 1

从标准序列中删除元素的已知习惯用法是 erase / remove idiom 。您首先调用remove算法，该算法将您要保留的所有元素移动到序列的前面，然后您erase序列后面的已删除元素。在 C ++ 11 中，它看起来像这样：

std::vector< std::string > strings;
strings.erase(
    std::remove_if(
        strings.begin(), strings.end()
      , []( std::string const& s ) -> bool
        {
            return /*whether to remove this item or not*/;
        }
    )
  , strings.end()
);

Answer 2

    std::sort(remove_these.begin(), remove_these.end());

    int counter = 0;
    auto end = std::remove_if(my_vec.begin(), my_vec.end(),
                             [&](const std::string&) mutable {
        return std::binary_search(remove_these.begin(), remove_these.end(), counter++);
    });
    my_vec.erase(end, my_vec.end());

这使用带有lambda函数的remove_if，如果在向量counter中找到当前元素的索引（由变量remove_these跟踪），则返回true。对该向量进行排序，以便可以使用binary_search作为优化。如果要删除的元素列表很小，那么不对它进行排序可能会更快，只需在lambda中使用它：

        return std::find(remove_these.begin(), remove_these.end(), counter++) != remove_these.end();

Answer 3

在您的情况下，我认为有两个值得考虑的问题：

您正在使用具有连续索引的容器，因此每次删除元素时，其后的所有元素都将被重新索引（这就是您必须在示例代码中以相反顺序执行删除的原因），< / LI>
该容器也发生在store its elements contiguously，因此任何删除都可能触发重新分配，并且至少提供元素副本以满足连续性约束。

鉴于这两个问题，在某些情况下将您希望保留的元素复制到新容器可能会很有趣，而不是删除。在您的情况下，复制元素似乎不应该是一个大问题，因为std::string的许多实现使用copy on write strategy，但您可能希望使用自己的验证。

要考虑的另一件事是要删除的索引集可以很好地存储在位向量中。它非常有效，并且显着简化了算法。您需要跟踪已移除的元素的有效数量。

我个人会想要一个简单的循环，但C ++提供了很多方法来实现类似的结果。这是循环版本：

    std::vector<bool> remove_these(my_vec.size(), false):
    remove_these[0] = remove_these[4] = true;

    std::vector<std::string> my_result;
    my_result.reserve(my_vec.size() - 2);

    for (int i = 0; i < remove_these.size(); ++i)
        if (!remove_these[i])
             my_result.push_back(my_vec[i]);

请注意使用reserve来避免在向量填充期间进行多次重新分配。

现在，剩下要做的就是将上面的代码包装在一个函数中，该函数将事先在bool向量中转换int向量：

template <typename IT>
void erase(std::vector<std::string> &my_vec, IT begin, IT end){
    std::vector<std::string> res;
    std::vector<bool> r(my_vec.size(), false);
    res.reserve(my_vec.size() - (end - begin));
    for (IT it = begin; it != end; ++it)
        r[*it] = true;
    for (int i = 0; i < r.size(); ++i)
        if (!r[i])
            res.push_back(my_vec[i]);
    my_vec = res;
}

那就是它。算法的时间复杂度约为 O（N + M），其中N和M是my_vec和remove_these的大小。或者，可以用remove_if替换第二个循环。

实际上，如果stl提供了一个迭代像remove_if这样的序列的函数，并调用一个谓词函数，该函数接受该迭代器的键和值，我们就可以用它{{1反转迭代器和一个lambda来检查给定的密钥是否在my_vec中，但时间复杂度会比上面的解决方案高一点。

使用索引向量来擦除另一个向量的索引

3 个答案: