下一个更大的元素 - https://leetcode.com/problems/next-greater-node-in-linked-list/答案

【问题标题】：Next Greater Element - https://leetcode.com/problems/next-greater-node-in-linked-list/下一个更大的元素 - https://leetcode.com/problems/next-greater-node-in-linked-list/
【发布时间】：2019-08-17 10:07:50
【问题描述】：

我用蛮力的方式回答了这个问题。我使用了两个循环，时间效率很差。这是代码：-

    public int[] nextLargerNodes(ListNode head) {
    int len = 0;
    ListNode temp = head;
    while(temp != null) {
        len++;
        temp = temp.next;
    }

    int[] answer = new int[len];
    temp = head;
    int i = 0;
    while(temp.next != null) {
        ListNode nextGreat = temp.next;
        while(nextGreat != null) {
            if(nextGreat.val > temp.val) {
                answer[i] = nextGreat.val;
                i++;
                break;
            }
            else {
                nextGreat = nextGreat.next;
            }
        }

        if(nextGreat == null) {
            answer[i++] = 0;
        }

        temp = temp.next;
    }

    answer[i] = 0;
    return answer;
}

然后我找到了另一种使用堆栈来解决问题的解决方案，但是该解决方案也使用了两个循环。第二种解决方案的效率要好得多，即使它不是 O(n)，因为它有两个循环。代码：-

public int[] nextLargerNodes(ListNode head) {
    ArrayList<Integer> A = new ArrayList<>();
    for (ListNode node = head; node != null; node = node.next)
        A.add(node.val);
    int[] res = new int[A.size()];
    Stack<Integer> stack = new Stack<>();
    for (int i = 0; i < A.size(); ++i) {
        while (!stack.isEmpty() && A.get(stack.peek()) < A.get(i))
            res[stack.pop()] = A.get(i);
        stack.push(i);
    }
    return res;
}

我想知道是什么让堆栈解决方案与蛮力方式相比效率更高，尽管这两种解决方案都有两个循环。

【问题讨论】：

第二种解决方案也有问题；我们需要从列表中推入第 i 个元素，而不是将 i 的值推入堆栈，例如 --stack.push(A.get(i));

标签： java data-structures stack

【解决方案1】：

第二个解决方案是 O(N)，即使它有两个循环。

内部循环的每次迭代都会从堆栈中弹出一个项目。这种情况会发生多少次？

【讨论】：

即使内循环的每次迭代都会弹出一个项目，但内循环通常会在外循环的每次迭代中运行不止一次？为什么说解是 O(N)？
不，它没有。外循环的每次迭代都恰好推送 1 个项目。内部循环的每次迭代都会弹出一个项目。弹出的项目不能多于推送的项目。
哦，据我了解，内部循环是 O(1) 而不是 O(n) 我假设它是，因为每次迭代只会弹出一个项目的外部 for 循环。因此，整个代码的时间复杂度为 O(n)，由外部 for 循环产生。我错过了什么吗？

【解决方案2】：

所以我们必须将链表转换为数组并将它们传递到堆栈。所以这里空间复杂度 O(1) 更好，时间复杂度 O(n) 在这方面是有效的。

【讨论】：