题目介绍

力扣1019题：leetcode-cn.com/problems/ne…

方法：单调栈

思路如下：

• 首先反转链表并计算链表长度

• 将反转后的链表放入单调栈，对于每个数num，要找到栈顶数字进行比较。

  • 如果它大于栈顶数字，就弹出栈顶数字，直到找到一个比它大的数字/栈空。
  • 如果它小于栈顶数字，就将栈顶数字保存。

反转后（这里我们还可以通过反转函数知道长度，进而初始化数组res）:

首先将5放入单调栈，因为此时栈空，所以res[2]=0

然后将1放入单调栈，因为栈顶数字5大于1，所以保存栈顶数字（res[1]=5）,再将1放入单调栈

最后是2，因为栈顶数字1小于2，所以弹出1；弹出后，栈顶数字5大于2，所以保存栈顶数字（res[0]=5）,然后放入2

最后链表走到末尾就可以停止循环，返回结果。

代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public int[] nextLargerNodes(ListNode head) {
        ListNode tail = reverse(head);
        Stack<Integer> stack = new Stack<>();
        //记录返回结果
        int[] res = new int[tail.val];
        int index = tail.val - 1;//最后一个节点的索引
        tail = tail.next;
        while(index >= 0){
            while(!stack.isEmpty() && tail.val >= stack.peek()){
                stack.pop();
            }

            //栈可能为空
            res[index] = stack.isEmpty() ? 0 : stack.peek();
            index--;
            stack.push(tail.val);
            tail = tail.next;
        }
        return res;
    }

    /**
     * 链表的反转
     */
    private ListNode reverse(ListNode head){
        //之所以返回dummy是为了用dummy.val保存链表的长度
        ListNode dummy = new ListNode(-1);
        int count = 0;
        ListNode cur = head, pre = null;
        while(cur != null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
            //记录链表节点个数
            count++;
        }
        //哑节点的值等于链表的长度
        dummy.val = count;
        dummy.next = pre;
        return dummy;
    }
}

复杂度分析

• 时间复杂度O(N)，反转链表是O(N)，单调栈遍历时每个数字只入栈出栈一次，所以是O(N)。
• 空间复杂度O(N)，有栈和res数组，是O(N)。