这种反向单链表算法的复杂性？答案

【问题标题】：Complexity of this reverse singly linked list algorithm?这种反向单链表算法的复杂性？
【发布时间】：2012-08-16 22:07:08
【问题描述】：

这个算法的复杂度是多少？我假设它是 O(N) 但我想澄清一下。如果我在链表中有一个尾部，我会假设这会更快，因为我会完全避免让 while(current != null) 循环循环到链表的末尾。

public void reverse() {
    Stack<Node> stack = new Stack<Node>();
    if (this.head != null || this.head.next != null) {
        Node current = this.head;
        while (current != null) {
            stack.push(current);
            current = current.next;
        }
        Node last = null;
        while (!stack.empty()) {
            if (last==null) {
                this.head = stack.pop();
                last = this.head;
                continue;
            }
            last.next = stack.pop();
            last = last.next;
            if (stack.empty()) {
                last.next = null;
            }
        }
    }
}

【问题讨论】：

您应该提出一个明确的问题，告诉我们您期望的答案。
我重新编辑了它，但本质上我是在问这个算法的运行时间复杂度是多少
是的，它是 O(n*constant)，即 O(n)，假设 java Stack push 和 pop 是 O(1)，恰好是这种情况。您的空间复杂度也是 O(n)，并且有一些方法可以在空间复杂度 O(1) 中做到这一点。

标签： java algorithm complexity-theory

【解决方案1】：

您通过迭代列表将所有链表元素推入堆栈这是一个 N 然后您迭代堆栈是另一个 N 所以您在 O(2N) 中排序符号

见how to reverse a list with O(1) space and O(n) time?

【讨论】：

所以基本上是 O(N) -- 线性时间？
如果我没记错我的复杂性理论，你可以把常数放在术语前面，所以是的，我认为它是 O(N)

【解决方案2】：

算法属于 O(N) 类。您正在使用 N 次静态操作（第一个循环），然后再次使用静态操作（第二个循环）； Stack.pop() 应该独立于“N”；所以这意味着它在 O(2N+c) 类中......而 O(2N+c) 在 O(2N) 类中，而 O(2N) 类在 O(N) 中。换句话说：例程的运行时间随着堆栈中元素的数量线性增加。

或者简单地说：是的，它属于 O(N) 类。

【讨论】：