You are given the head of a linked list with n nodes.
For each node in the list, find the value of the next greater node. That is, for each node, find the value of the first node that is next to it and has a strictly larger value than it.
Return an integer array answer where answer[i] is the value of the next greater node of the ith node (1-indexed). If the ith node does not have a next greater node, set answer[i] = 0.
Example 1:
Input: head = [2,1,5]
Output: [5,5,0]
Example 2:
Input: head = [2,7,4,3,5]
Output: [7,0,5,5,0]
Constraints:
The number of nodes in the list is n.
1 <= n <= 104
1 <= Node.val <= 109
Solutions
Solution 1: Monotonic Stack
The problem requires finding the next larger node for each node in the linked list, that is, finding the first node to the right of each node in the linked list that is larger than it. We first traverse the linked list and store the values in the linked list in an array $nums$. For each element in the array $nums$, we just need to find the first element to its right that is larger than it. The problem of finding the next larger element can be solved using a monotonic stack.
We traverse the array $nums$ from back to front, maintaining a stack $stk$ that is monotonically decreasing from the bottom to the top. During the traversal, if the top element of the stack is less than or equal to the current element, we loop to pop the top element of the stack until the top element of the stack is larger than the current element or the stack is empty.
If the stack is empty at this time, it means that the current element does not have a next larger element, otherwise, the next larger element of the current element is the top element of the stack, and we update the answer array $ans$. Then we push the current element into the stack and continue the traversal.
After the traversal is over, we return the answer array $ans$.
The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the linked list.
1 2 3 4 5 6 7 8 9101112131415161718192021
# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclassSolution:defnextLargerNodes(self,head:Optional[ListNode])->List[int]:nums=[]whilehead:nums.append(head.val)head=head.nextstk=[]n=len(nums)ans=[0]*nforiinrange(n-1,-1,-1):whilestkandstk[-1]<=nums[i]:stk.pop()ifstk:ans[i]=stk[-1]stk.append(nums[i])returnans
/** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */funcnextLargerNodes(head*ListNode)[]int{nums:=[]int{}for;head!=nil;head=head.Next{nums=append(nums,head.Val)}stk:=[]int{}n:=len(nums)ans:=make([]int,n)fori:=n-1;i>=0;i--{forlen(stk)>0&&stk[len(stk)-1]<=nums[i]{stk=stk[:len(stk)-1]}iflen(stk)>0{ans[i]=stk[len(stk)-1]}stk=append(stk,nums[i])}returnans}