Question

嗯，我认为这个问题几乎总结了一下。我有一个独特项目的forward_list，并希望从中删除一个项目：

std::forward_list<T> mylist;
// fill with stuff

mylist.remove_if([](T const& value)
  {
    return value == condition;
  });

我的意思是，这种方法运行正常，但效率很低，因为一旦找到并删除了项目，它就会继续搜索。有更好的方法还是我需要手动完成？

Answer 1

如果您只想删除第一个匹配项，则可以使用std::adjacent_find后跟成员erase_after

#include <algorithm>
#include <cassert>
#include <forward_list>
#include <iostream>
#include <ios>
#include <iterator>

// returns an iterator before first element equal to value, or last if no such element is present
// pre-condition: before_first is incrementable and not equal to last
template<class FwdIt, class T>
FwdIt find_before(FwdIt before_first, FwdIt last, T const& value)
{
    assert(before_first != last);
    auto first = std::next(before_first);
    if (first == last) return last;
    if (*first == value) return before_first;
    return std::adjacent_find(first, last, [&](auto const&, auto const& R) { 
        return R == value; 
    });
}

int main() 
{
    auto e = std::forward_list<int>{};
    std::cout << std::boolalpha << (++e.before_begin() == end(e)) << "\n";
    std::cout << (find_before(e.before_begin(), end(e), 0) == end(e)) << "\n";

    auto s = std::forward_list<int>{ 0 };
    std::cout << (find_before(s.before_begin(), end(s), 0) == s.before_begin()) << "\n";

    auto d = std::forward_list<int>{ 0, 1 };
    std::cout << (find_before(d.before_begin(), end(d), 0) == d.before_begin()) << "\n";
    std::cout << (find_before(d.before_begin(), end(d), 1) == begin(d)) << "\n";
    std::cout << (find_before(d.before_begin(), end(d), 2) == end(d)) << "\n";

    // erase after
    auto m = std::forward_list<int>{ 1, 2, 3, 4, 1, 3, 5 };
    auto it = find_before(m.before_begin(), end(m), 3);
    if (it != end(m)) 
        m.erase_after(it);
    std::copy(begin(m), end(m), std::ostream_iterator<int>(std::cout, ","));
}

Live Example

一旦找到匹配，这将立即停止。请注意，adjacent_find采用二元谓词，并且通过仅比较第二个参数，我们在要删除的元素之前得到一个迭代器，以便erase_after实际上可以删除它。复杂性为O(N)，因此你不会比这更有效率。

Answer 2

FWIW，这是另一个简短的版本

template< typename T, class Allocator, class Predicate >
bool remove_first_if( std::forward_list< T, Allocator >& list, Predicate pred )
{
    auto oit = list.before_begin(), it = std::next( oit );
    while( it != list.end() ) {
        if( pred( *it ) ) { list.erase_after( oit ); return true; }
        oit = it++;
    }
    return false;
}

Answer 3

~~标准库中没有任何内容可以直接应用。~~实际上，有。请参阅@ TemplateRex的答案。

您也可以自己编写（特别是如果您想将搜索与删除相结合），如下所示：

template <class T, class Allocator, class Predicate>
bool remove_first_if(std::forward_list<T, Allocator> &list, Predicate pred)
{
  auto itErase = list.before_begin();
  auto itFind = list.begin();
  const auto itEnd = list.end();
  while (itFind != itEnd) {
    if (pred(*itFind)) {
      list.erase_after(itErase);
      return true;
    } else {
      ++itErase;
      ++itFind;
    }
  }
  return false;
}

Answer 4

必须自己动手......

template <typename Container, typename Predicate>
void remove_first_of(Container& container, Predicate p)
{
  auto it = container.before_begin();
  for (auto nit = std::next(it); ; it = nit, nit = std::next(it))
  {
    if (nit == container.end())
      return;
    if (p(*nit))
    {
      container.erase_after(it);
      return;
    }
  }
}

更完整的例子......

Answer 5

当我在80年代早期学习编程时，这种东西曾经是一种标准练习。回忆一下解决方案可能会很有趣，并将其与C ++中的解决方案进行比较。实际上那是在Algol 68中，但我不会强加给你并将翻译成C.给出

typedef ... T;
typedef struct node *link;
struct node { link next; T data; };

可以编写，意识到如果可以取消链接第一个节点，则需要传递列表头指针的地址：

void search_and_destroy(link *p_addr, T y)
{
  while (*p_addr!=NULL && (*p_addr)->data!=y)
    p_addr = &(*p_addr)->next;
  if (*p_addr!=NULL)
  {
    link old = *p_addr;
    *p_addr = old->next; /* unlink node */
    free(old); /* and free memory */
  }
}

那里出现了很多*p_addr;它是最后一个，它是赋值的LHS，这就是首先需要指针地址的原因。请注意，尽管有明显的复杂性，但语句p_addr = &(*p_addr)->next;只是用它指向的值替换指针，然后添加一个偏移量（这里为0）。

可以引入一个辅助指针值来稍微减轻代码，如下所示

void search_and_destroy(link *p_addr, T y)
{
  link p=*p_addr;
  while (p!=NULL && p->data!=y)
    p=*(p_addr = &p->next);
  if (p!=NULL)
  {
    *p_addr = p->next;
    free(p);
  }
}

但这基本上是相同的代码：任何体面的编译器都应该意识到在第一个例子中连续多次使用指针值*p_addr，并将其保存在寄存器中。

现在使用std::forward_list<T>，我们不允许访问链接节点的指针，而是让那些笨拙的“迭代器指向实际操作之前的一个节点”。我们的解决方案变为

void search_and_destroy(std::forward_list<T> list, T y)
{
  std::forward_list<T>::iterator it = list.before_begin();
  const std::forward_list<T>::iterator NIL = list.end();

  while (std::next(it)!=NIL && *std::next(it)!=y)
    ++it;
  if (std::next(it)!=NIL)
    list.erase_after(it);
}

我们可以保留第二个迭代器变量来保存std::next(it)，而不必每次都拼出它（当我们增加it时不要忘记刷新它的值）并且基本上得到Daniel的答案弗雷。（我们可以尝试使该变量成为*T类型的指针，而不是等于&*std::next(it)，这足以让我们使用它，但实际上确保它有点麻烦。在std::next(it)==NIL时成为空指针，因为标准不允许我们使用&*NIL）。

我不禁感到，自从过去以来，这个问题的解决方案并没有变得更加优雅。

如何从forward_list中有效地remove_if只有一个元素？

5 个答案: