remove_if 然后擦除向量是否有效？

Question

虽然有几十个关于remove_if + erase for vector的问题。 我找不到这种动作的表现。 当我写：

    myVector.erase(remove_if(myVector.begin(),
                         myVector.end(),
                         some_predicate), myVector.end());

remove if 将返回一个迭代器，指向最后一个相关项 + 1（我们称之为 X）。 我相信这会在 O(n) 内发生。

但是擦除将如何工作？

• 如果擦除尝试从 X 删除到 myVector.end()，它将是 O(n^2)，因为它会导致将向量复制到新位置，并且会有 O(n) 新分配从堆中。
• 但如果它将从 myVector.end() 删除到 X，它可以在 O(n) 内完成，更重要的是不会分配新内存（我试图避免这种情况）。

谢谢。

Answer 1

vector::erase 的复杂度是well-defined：

线性：调用T的析构函数的次数与擦除的元素个数相同，调用T的赋值运算符的次数等于擦除元素后向量中的元素个数

它在内部的工作方式（即如何准确地删除你的元素）是无关紧要的。

remove_if的复杂度也是defined，是

恰好是谓词的 std::distance(first, last) 应用。

所以你的代码具有线性复杂度。

Answer 2

为什么不使用 swap 'n pop 方法？我们在优化向量中的擦除方面犯了很多错误，发现这是最快的，因为它具有O(1) 复杂性。唯一的缺点是它不保持秩序。很多情况下都很好。这是此类操作的模板方法：

template<typename T>
inline typename std::vector<T>::iterator unorderedErase(std::vector<T>& p_container,
                                                        typename std::vector<T>::iterator p_it)
{
    if (p_it != p_container.end() - 1)
    {
        std::swap(*p_it, p_container.back());
        p_container.pop_back();
        return p_it;
    }
    // else
    p_container.pop_back();
    return p_container.end();
}

Answer 3

考虑这个向量：

|0|1|2|3|4|5|6|7|8|9|

我们使用remove_if 删除所有4 的倍数的元素：

std::remove_if(v.begin(), v.end(), [](auto i){ return i != 0 && !(i%4); });

这开始使用迭代器 X 遍历向量，直到找到谓词返回 true 的元素：

|0|1|2|3|4|5|6|7|8|9|
         X

这是我们要删除的第一个元素。

接下来，它创建另一个指向下一个元素 Y = X+1 的迭代器，并检查 *Y 的谓词：

|0|1|2|3|4|5|6|7|8|9|
         X Y

谓词是假的，所以我们想保留那个元素，所以它将下一个元素分配给我们要删除的元素，通过*X = std::move(*Y)：

|0|1|2|3|5|5|6|7|8|9|
         X Y            *X = std::move(*Y)

所以我们有两个迭代器，X 和 Y，其中 X 指向“输出”中的下一个元素（即我们不删除的元素），Y 是下一个要考虑删除的元素。

我们将两个迭代器移动到下一个位置，检查 Y 的谓词（再次为假），然后进行另一个赋值：

|0|1|2|3|5|6|6|7|8|9|
           X Y          *X = std::move(*Y)

然后在下一个位置再次执行相同的操作：

|0|1|2|3|5|6|7|7|8|9|
             X Y       *X = std::move(*Y)

然后它继续前进，但发现谓词对 Y 为真

|0|1|2|3|5|6|7|7|8|9|
               X Y

所以它只是增加 Y，跳过该元素，因此不会将其复制到 X 的“输出”位置：

|0|1|2|3|5|6|7|7|8|9|
               X   Y 

谓词对 Y 不成立，因此将其分配给 X：

|0|1|2|3|5|6|7|9|8|9|
               X   Y     *X = std::move(*Y)

然后它再次增加 X 和 Y

|0|1|2|3|5|6|7|9|8|9|
                 X   Y

现在 Y 已经结束，所以我们返回 X（它指向输出序列的末尾，即我们想要保留的元素）。

在remove_if 返回 X 之后，我们调用v.erase(X, v.end())，因此向量为从 X 到末尾的每个元素调用析构函数：

|0|1|2|3|5|6|7|9|~|~|
                 X   end

然后设置大小，使向量在 X 处结束：

|0|1|2|3|5|6|7|9|
                 end

在v.capacity() >= v.size()+2 之后，因为最后两个元素使用的内存仍然存在，但未使用。