Question

此算法的复杂性是什么？我假设它是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;
            }
        }
    }
}

Answer 1

您正在通过迭代列表将所有链接列表元素推送到堆栈上，这是一个N然后您迭代堆栈，这是另一个N，因此您在O（2N）中订购符号

请参阅how to reverse a list with O(1) space and O(n) time?

Answer 2

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

或简单地说：是的，它在O（N）类中。

这个反向单链表算法的复杂性？

2 个答案: