为什么 std::list::reverse 有 O(n) 复杂度？

Question

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

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

Answer 1

它是 O(n) 仅仅是因为它需要以相反的顺序复制列表。每个单独的项目操作都是 O(1)，但整个列表中有 n 个。

当然，在为新列表设置空间以及之后更改指针等方面涉及一些常数时间操作。一旦包含一阶 n 因子，O 表示法就不会考虑单个常数。

Answer 2

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

Answer 3

只是一个算法解释。 想象一下，您有一个包含元素的数组，那么您需要反转它。 基本思想是迭代每个元素，改变元素 第一个位置到最后一个位置，第二个位置的元素到倒数第二个位置，依此类推。当您到达数组的中间时，您将更改所有元素，因此在 (n/2) 次迭代中，这被认为是 O(n)。

Answer 4

如果列表存储一个允许交换“prev”和“next”指针含义的标志，它可能是O(1)每个节点都有。如果反转列表是一项频繁的操作，那么这样的添加实际上可能很有用，我不知道为什么当前标准会禁止实施它。但是，拥有这样一个标志会使列表的普通 遍历 更加昂贵（如果只是一个常数因素），因为而不是

current = current->next;

在列表迭代器的operator++ 中，你会得到

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

这不是您决定轻松添加的内容。鉴于列表的遍历频率通常比反转列表的频率高得多，标准强制这种技术是非常不明智的。因此，允许逆运算具有线性复杂度。但是请注意，t ∈ O(1) ⇒ t ∈ O(n) 因此，如前所述，在技术上实现您的“优化”是允许的。

如果您来自 Java 或类似背景，您可能想知道为什么迭代器每次都必须检查标志。难道我们不能有两个不同的迭代器类型，它们都派生自一个共同的基类型，并让std::list::begin 和std::list::rbegin 多态地返回适当的迭代器吗？虽然可能，但这会使整个事情变得更糟，因为推进迭代器现在将是一个间接（难以内联）的函数调用。在 Java 中，无论如何，您通常都会付出这个代价，但话又说回来，这也是许多人在性能至关重要时选择 C++ 的原因之一。

正如 cmets 中的 Benjamin Lindley 所指出的，由于不允许 reverse 使迭代器无效，标准允许的唯一方法似乎是将指针存储回迭代器内的列表，这会导致双精度- 间接内存访问。

Answer 5

当然，因为所有支持双向迭代器的容器都有 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。

Answer 6

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

不幸的是，这基本上会降低任何其他操作的性能（尽管不会更改渐近运行时）。在每个操作中，都需要参考一个布尔值来考虑是否跟随链接的“下一个”或“上一个”指针。

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

Answer 7

因为它必须遍历每个节点（ntotal）并更新它们的数据（更新步骤确实是O(1)）。这使得整个操作O(n*1) = O(n)。