LeetCode 1019. Next Greater Node In Linked List

最新推荐文章于 2025-09-10 15:24:29 发布

转载最新推荐文章于 2025-09-10 15:24:29 发布 · 108 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/Dylan-Java-NYC/p/10967068.html

文章标签：

#数据结构与算法 #java

本文提供了一种解决LeetCode上“链表的下一个更大节点”问题的有效算法。通过逆序链表并使用栈结构，文章详细解释了如何找出每个节点的下一个更大的元素，包括时间复杂度和空间复杂度分析。

原题链接在这里：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 }