为什么std :: list :: reverse具有O（n）复杂度？

为什么std::listC ++标准库中类的反向函数具有线性运行时？我认为对于双向链表，反向函数应该是O（1）。

反转双向链接列表应该只涉及切换头和尾指针。

假设reverse是O（1）。（再次假设）可能有一个布尔列表成员，它指示链接列表的方向当前与创建列表的原始方向相同还是相反。

不幸的是，这将降低其他任何操作的性能（尽管不更改渐近运行时）。在每个操作中，都需要查询一个布尔值，以考虑是否遵循链接的“下一个”或“上一个”指针。

由于这大概被认为是相对少见的操作，因此该标准（该标准不规定实现，仅要求复杂性）规定该复杂度可以是线性的。这允许“下一个”指针始终明确地指示相同的方向，从而加快了常见情况的操作。

这可能是Ø（1）如果该列表将存储允许调换“的含义的标志prev”和“ next”指针每个节点都有。如果反转列表是经常的操作，那么实际上添加这样的列表可能会有用，并且我不知道任何理由为何当前标准禁止实施它。但是，拥有这样的标志会使列表的普通遍历更加昂贵（如果仅通过一个恒定的因素），因为

current = current->next;

在operator++列表迭代器的中，您将获得

if (reversed)
  current = current->prev;
else
  current = current->next;

这不是您决定轻松添加的内容。考虑到列表遍历的次数通常比翻转遍历的次数多，因此标准强制采用此技术是非常不明智的。因此，允许反向运算具有线性复杂度。不过请注意，即牛逼 ∈ Ô（1）⇒ 牛逼 ∈ Ø（ñ），因此，如前所述，实现您“优化”技术将被允许。

如果您来自Java或类似的背景，您可能想知道为什么迭代器每次都要检查标志。难道我们不是有两个不同的迭代器类型，无论从公共基类派生，并有std::list::begin与std::list::rbegin多态返回相应的迭代器？可能的话，这会使整个情况变得更糟，因为推进迭代器现在将是间接（很难内联）的函数调用。在Java中，您还是要按常规方式支付此价格，但是再次重申，这是许多人在性能至关重要时使用C ++的原因之一。

正如本杰明·林德利（Benjamin Lindley）在评论中所指出的那样，由于reverse不允许迭代器无效，因此标准允许的唯一方法似乎是将指向指针的指针存储在迭代器内部，这会导致双重间接内存访问。

当然，因为所有支持双向迭代器的容器都具有rbegin（）和rend（）的概念，所以这个问题没有意义吗？

构建一个代理来反转迭代器并通过该代理访问容器很简单。

这种非运算的确是O（1）。

如：

#include <iostream>
#include <list>
#include <string>
#include <iterator>

template<class Container>
struct reverse_proxy
{
    reverse_proxy(Container& c)
    : _c(c)
    {}

    auto begin() { return std::make_reverse_iterator(std::end(_c)); }
    auto end() { return std::make_reverse_iterator(std::begin(_c)); }

    auto begin() const { return std::make_reverse_iterator(std::end(_c)); }
    auto end() const { return std::make_reverse_iterator(std::begin(_c)); }

    Container& _c;
};

template<class Container>
auto reversed(Container& c)
{
    return reverse_proxy<Container>(c);
}

int main()
{
    using namespace std;
    list<string> l { "the", "cat", "sat", "on", "the", "mat" };

    auto r = reversed(l);
    copy(begin(r), end(r), ostream_iterator<string>(cout, "\n"));

    return 0;
}

预期输出：

mat
the
on
sat
cat
the

鉴于此，在我看来，标准委员会没有花时间要求对容器进行O（1）逆序排序，因为这是没有必要的，并且标准库很大程度上是基于仅强制要求必需的内容而建立的，避免重复。

只是我的2c。

因为它必须遍历每个节点（n总计）并更新其数据（更新步骤的确是O(1)）。这使整个操作成为可能O(n*1) = O(n)。

它还为每个节点交换上一个和下一个指针。这就是为什么需要线性的原因。尽管可以在O（1）中完成，但是使用此LL的函数是否也将有关LL的信息作为输入，例如它是正常访问还是反向访问。

仅是算法解释。假设您有一个包含元素的数组，那么您需要将其反转。基本思想是在每个元素上进行迭代，以将第一个位置上的元素更改为最后一个位置，将第二个位置上的元素更改为倒数第二个位置，依此类推。当您到达数组的中间时，将更改所有元素，因此将在（n / 2）次迭代中被更改为O（n）。

之所以为O（n）只是因为它需要以相反的顺序复制列表。每个单独的项目操作均为O（1），但在整个列表中有n个。

当然，在设置新列表的空间以及之后更改指针等过程中涉及到一些常量时间操作。一旦包含一阶n因子，O标记就不会考虑单个常量。