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

这个算法的复杂度是多少？我假设是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;
            }
        }
    }
}

public void reverse（）{
堆栈=新堆栈（）；
if（this.head！=null | | this.head.next！=null）{
节点电流=this.head；
while（当前！=null）{
堆栈推送（当前）；
当前=当前。下一步；
}
节点last=null；
而（！stack.empty（））{
if（last==null）{
this.head=stack.pop（）；
最后=这个头；
继续；
}
last.next=stack.pop（）；
last=last.next；
if（stack.empty（））{
last.next=null；
}
}
}
}

通过迭代列表，将所有链表元素推到堆栈上，这是一个N，然后迭代堆栈，这是另一个N，因此您可以按O（2N）排序表示法

---

请参见

通过迭代列表，将所有链表元素推到堆栈上，这是一个N，然后迭代堆栈，这是另一个N，因此您可以按O（2N）排序表示法

---

参见

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

---

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

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

---

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

你应该问一个明确的问题，告诉我们你期望的答案是什么。我重新编辑了它，但本质上我是在问这个算法的运行时复杂度会超过什么，它是O（N*常量），也就是O（N），假设java堆栈推送和pop是O（1），这恰好是这样。你的空间复杂度也是O（n），在空间复杂度O（1）中也有这样做的方法。你应该问一个明确的问题，告诉我们你期望的答案。我重新编辑了它，但本质上我是问这个算法的运行时复杂度会超过什么，它是O（n*常量），也就是O（n），假设java堆栈推送和pop是O（1），事实正好如此。你的空间复杂度也是O（n），在空间复杂度O（1）中有很多方法可以做到这一点。所以基本上是O（n）-线性时间。如果我正确地记得我的复杂性理论，你可以把常数放在前面。所以，YEHA，我会考虑O（n），所以基本上是O（n）。线性时间？如果我正确地记得我的复杂性理论，你可以把常数放在前面，这样我就可以把它看作是O（n）。