Next Greater Node In Linked List

We are given a linked list with head as the first node.  Let's number the nodes in the list: node_1, node_2, node_3, ... etc.

Each node may have a next larger value: for node_i, next_larger(node_i) is the node_j.val such that j > i, node_j.val > node_i.val, and j is the smallest possible choice.  If such a j does not exist, the next larger value is 0.

Return an array of integers answer, where answer[i] = next_larger(node_{i+1}).

Note that in the example inputs (not outputs) below, arrays such as [2,1,5] represent the serialization of a linked list with a head node value of 2, second node value of 1, and third node value of 5.

Example 1:

Input: [2,1,5]
Output: [5,5,0]

Example 2:

Input: [2,7,4,3,5]
Output: [7,0,5,5,0]

思路：单调栈的算法, 这题如果是array非常直观，但是是linkedlist，无法知道index的信息，怎么办？那么我可以加入index的信息，递增的index，那么把linkedlist map成带index 的node array，每个node里面有index 信息，那么在求res[index] 的时候，就从node里面拿index，来populate结果了。扫两遍，O(N)。

/**
 * 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 {
    private class Node {
        public int index;
        public int value;
        public Node(int index, int value) {
            this.index = index;
            this.value = value;
        }
    }
    
    public int[] nextLargerNodes(ListNode head) {
        int length = getLength(head);
        int[] res = new int[length];
        ListNode cur = head;
        Stack<Node> stack = new Stack<Node>();
        int index = 0;
        while(cur != null) {
            Node node = new Node(index++, cur.val);
            while(!stack.isEmpty() && stack.peek().value < cur.val) {
                res[stack.pop().index] = cur.val;
            }
            cur = cur.next;
            stack.push(node);
        }
        return res;
    }
    
    private int getLength(ListNode head) {
        ListNode cur = head;
        int len = 0;
        while(cur != null) {
            len++;
            cur = cur.next;
        }
        return len;
    }
}