【Leetcode】1019-链表中的下一个更大节点

题目简述

给定一个长度为 n 的链表 head。
对于列表中的每个节点，查找下一个更大节点的值。也就是说，对于每个节点，找到它旁边的第一个节点的值，这个节点的值严格大于它的值。
返回一个整数数组 answer ，其中 answer[i] 是第 i 个节点( 从1开始 )的下一个更大的节点的值。如果第 i 个节点没有下一个更大的节点，设置 answer[i] = 0 。

示例 1：
输入：head = [2,1,5]
输出：[5,5,0]

示例 2：
输入：head = [2,7,4,3,5]
输出：[7,0,5,5,0]

提示：
链表中节点数为 n
1 <= n <= 10⁴
1 <= Node.val <= 10⁹

数据结构：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

思路分析

【最直接的方法】需要双层循环实现：外层循环从左到右遍历链表所有节点；每遍历到一个节点，需要进入内层循环，从当前节点往后遍历找到第一个大于当前节点值的节点。

• 最差的情况是：原本链表的值是逆序排列的，这样时间复杂度为$O(n^2)$，运行会超时。
• 最好的情况是：链表的值是顺序排列的，这样每个节点的下一个更大节点 就是其next节点，这种情况下只需一次遍历。
• 对于一般情况：在一次遍历中：对于next节点的值大于当前节点的，可以立即输出next节点的值作为下一个更大节点 的结果；对于next节点的值不大于当前节点的，先搁置，并对每一个被搁置的节点 ，创建一个子循环遍历其后续节点，若遇到了值大于被搁置节点的节点，则可取该节点值作为被搁置节点的下一个更大节点的结果。为了获得每一个被搁置节点的下一个更大节点 ， 都需要遍历一遍链表的后续节点。

有没有改进方法呢？——有，优化对被搁置的节点的处理方式。

【改进方法】：相对于最直接的方法中对每一个被搁置的节点 遍历一遍其后续节点以找到下一个更大节点。换一个角度看，如果我们将被搁置的节点暂存起来（可暂且将其结果置为0，假设后续没有比它大的值了），对于链表中每一个当前经过的节点 curr，遍历这些目前被搁置的节点与其进行比较。则在这个过程中，若有小于curr的被搁置节点，则该被搁置节点可以取curr的值作为其下一个更大节点 的结果。总结：相对于最直接的方法-遍历每个被搁置节点的后续节点，改进方法在经过每个节点时遍历那些被搁置的节点。

看起来最直接的方法和改进方法的时间复杂度差不多，都是涉及双层循环的。但其实方式二的好处在于：
方式二需要使用一个数据结构来存储被搁置的节点，如果选用合适的数据结构可以大量减少迭代节点的个数。

那么选用什么数据结构来存储被搁置的节点呢？

注意：被搁置节点是逆序的。
假设以列表来存储被搁置的节点，因为被搁置元素是在遍历链表过程中动态进出列表的，即已进入被搁置列表的节点当遇到下一个更大节点 时就会从列表中被删除不再被搁置，所以后进入列表的节点一定是小于当前节点的（否则可以输出结果而不需被搁置），也就是说进入列表的被搁置的节点刚好形成了逆序。

选用合适的数据结构来存储被搁置的节点。
一般首先想到的是列表，但因为被搁置节点在列表中是逆序的，这样我们需要所有被搁置节点都参与比较（也就是需要从头到尾遍历列表）。因为如果列表中靠前的被搁置节点大于链表当前经过的节点curr，并不能说明列表中靠后的被搁置节点不会小于curr 而获取下一个更大节点 的结果，需要全部遍历比较才行，总算法时间复杂度接近$O(n^2)$。
如果反过来先取最小的被搁置节点呢？就避免重复遍历大于curr的被搁置节点了。容易发现，从列表末尾开始取值，这个数据结构其实就是先进后出的栈。并且，此题中我们将搁置节点按顺序存入栈中，就会得到一个元素值递减的单调栈。（题【Leetcode】739-每日温度就是典型的单调栈应用场景）
使用这个单调栈的好处在于，若链表当前经过的节点curr的值大于栈顶元素，栈顶元素即获得了下一个更大节点 的结果而出栈，剩余栈元素虽然大于刚出栈的元素，但有可能小于链表当前经过节点curr的值，此时可以获取下一个更大节点 的结果为curr，然后直接出栈。因此可以继续比较直到某个栈顶元素大于链表当前经过节点值。
栈相比于列表，避免了对其中大量元素的重复遍历，对每个节点，只有入栈和出栈时访问一次，大大节省了时间开销将对被搁置节点的遍历的时间复杂度直接由$O(n)$降为了$O(1)$，总算法时间复杂度为$O(n)$。

代码实现时需要注意的是，入栈被搁置元素时，还需要记录其结果的预期位置，否则找到下一个更大节点 的结果后不知道要放到结果列表的哪个位置。

代码示例

class Solution:
    def nextLargerNodes(self, head: Optional[ListNode]) -> List[int]:
        stack_node = []
        ind = 0
        res = []
        while head:
            while stack_node and head.val > stack_node[-1][0]:
                res[stack_node[-1][1]] = head.val
                stack_node.pop()
            if not head.next:
                res.append(0)
            elif head.next.val > head.val:
                res.append(head.next.val)
            else:
                stack_node.append((head.val, ind))
                res.append(0)
            head = head.next
            ind += 1
        return res

测试用例1：[9,7,6,7,6,9]
期望结果: [0,9,7,9,9,0]

测试用例2：[1,7,5,1,9,2,5,1]
期望结果: [7,9,9,9,0,5,0,0]

算法复杂度

时间复杂度 $O(n)$ ：时间消耗主要在遍历链表$O(n)$，对栈内元素的操作只有入栈和出栈时各访问一次，最坏情况下所有节点都需要入栈，那么时间开销最多为O(2n)，因此总时间复杂度为$O(n)$。
空间复杂度 $O(n)$：存储被搁置节点，取决于链表长度n。