LeetCode 1019. Next Greater Node In Linked List

2019-06-03 13:54:26 阅读：259 来源： 互联网

标签：Node node head ListNode Greater int list List next

原题链接在这里：https://leetcode.com/problems/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.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 <= node.val <= 10^9 for each node in the linked list.
The given list has length in the range [0, 10000].

题解：

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

利用stack记录从后向前渐渐变小的栈.

reverse list后就可以从后向前iterate list. 遇到一个点，在stack中一直pop到比自己大的点就是next greater element. 如果stack空了也没找到，就是没有.

记下结果后再把当前点push到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 }

标签：Node,node,head,ListNode,Greater,int,list,List,next
来源： https://www.cnblogs.com/Dylan-Java-NYC/p/10967068.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

LeetCode 1019. Next Greater Node In Linked List