LeetCode 1019. Next Greater Node In Linked List Next Greater Element I Next Greater Element II

Original title link here: https://leetcode.com/problems/next-greater-node-in-linked-list/

topic:

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.valsuch 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]

Example 3:

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

Note:

1. 1 <= node.val <= 10^9 for each node in the linked list.
2. The given list has length in the range [0, 10000].

answer:

类似Next Greater Element I, Next Greater Element II.

Using recording stack gradually decreases from the front stack.

reverse list from back to front after iterate list. encountered a point to pop the stack has been bigger than his point is next greater element. If the stack is empty did not find, it is not.

And then write down the results of the current point in the push to the stack.

Time Complexity: O(n).

Space: O(n).

AC Java:

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     int val;
 5  *     ListNode next;
 6  *     ListNode(int x) { val = x; }
 7  * }
 8  */
 9 class Solution {
10     public int[] nextLargerNodes(ListNode head) {
11         if(head == null){
12             return new int[0];
13         }
14         
15         if(head.next == null){
16             return new int[]{0};
17         }
18         
19         int len = getLength(head);
20         int [] res = new int[len];
21         head = reverse(head);
22         Stack<Integer> stk = new Stack<Integer>();
23         
24         for(int i = 0; i<len; i++){
25             while(!stk.isEmpty() && head.val>=stk.peek()){
26                 stk.pop();
27             }
28             
29             res[len-i-1] = stk.isEmpty() ? 0 : stk.peek();
30             stk.push(head.val);
31             head = head.next;
32         }
33         
34         return res;
35     }
36     
37     private ListNode reverse(ListNode head){
38         if(head == null || head.next == null){
39             return head;
40         }
41         
42         ListNode tail = head;
43         ListNode cur = head;
44         ListNode pre;
45         ListNode temp;
46         while(tail.next != null){
47             pre = cur;
48             cur = tail.next;
49             temp = cur.next;
50             cur.next = pre;
51             tail.next = temp;
52         }
53         
54         return cur;
55     }
56     
57     private int getLength(ListNode head){
58         int res = 0;
59         while(head != null){
60             head = head.next;
61             res++;
62         }
63         
64         return res;
65     }
66 }