1019. 链表中的下一个更大节点

链表算法题（程序员面试宝典）

解题思路主要来源于leetcode官方与《程序员面试宝典》。

1019. 链表中的下一个更大节点

给出一个以头节点 head 作为第一个节点的链表。链表中的节点分别编号为：node_1, node_2, node_3, … 。

每个节点都可能有下一个更大值（next larger value）：对于 node_i，如果其 next_larger(node_i) 是 node_j.val，那么就有 j > i 且 node_j.val > node_i.val，而 j 是可能的选项中最小的那个。如果不存在这样的 j，那么下一个更大值为 0 。

返回整数答案数组 answer，其中 answer[i] = next_larger(node_{i+1}) 。

注意：在下面的示例中，诸如 [2,1,5] 这样的输入（不是输出）是链表的序列化表示，其头节点的值为 2，第二个节点值为 1，第三个节点值为 5 。

示例 1：

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

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

输入：[1,7,5,1,9,2,5,1]
输出：[7,9,9,9,0,5,0,0]

提示：

对于链表中的每个节点，1 <= node.val <= 10^9
给定列表的长度在 [0, 10000] 范围内

解题方法

解题思路1

双循环遍历，找curNode后第一个比curNode.val大的节点node，找到的话，将int[i] = node.val，未找到的话 int[i] = 0。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] nextLargerNodes(ListNode head) {
        //存储结果 
        ArrayList<Integer> result = new ArrayList<Integer>();
        //双循环遍历，将curNode与其后每一个节点
        ListNode curNode = head;

        while(curNode.next!=null){
            ListNode node = curNode.next;
            //flag: 标记是否找到curNode后第一个比curNode.val大的节点，true:yes false:no
            boolean flag = false;
            while(node!=null){
                if(node.val>curNode.val){
                    //找到curNode后第一个最大
                    flag = true;
                    break;
                }
                node = node.next;
            }

            if(flag == true){
                //找到curNode后第一个比curNode.val大的节点
                result.add(node.val);
            }else{
                //未找到curNode后比curNode.val大的节点
                result.add(0);
            }

            curNode = curNode.next;
        }
        result.add(0);

        int[] resultInt = new int[result.size()];
        for(int i=0;i<result.size();i++){
            resultInt[i] = result.get(i);
        }
        return resultInt;
    }
}

解题思路2

单调栈的思想。思路来源：https://labuladong.github.io/ebook/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E7%B3%BB%E5%88%97/%E5%8D%95%E8%B0%83%E6%A0%88.html

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] nextLargerNodes(ListNode head) {

        //存储链表值
        ArrayList<Integer> data = new ArrayList<Integer>();
        while(head!=null){
            data.add(head.val);
            head = head.next;
        }
        //存储结果
        int[] result = new int[data.size()];
        //单调栈的思想,栈用来存储节点值
        Stack<Integer> s = new Stack<Integer>();

        //data中的节点数
        int num = data.size();
        for(int i=num-1;i>=0;i--){
            while(!s.empty()&&s.peek()<=data.get(i)){
                //矮个子先出栈
                s.pop();
            }
            //栈不为空说明有高个，即为当前result[i]的值，否则为无效值
            result[i] = !s.empty()?s.peek():0;
            //将当前data[i]值加入栈中
            s.add(data.get(i));
        }
       
        return result;
    }
}

解题思路3

单调栈的思想，遍历链表，从前往后压栈。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] nextLargerNodes(ListNode head) {
        //单调栈的思想

        //存储节点的索引值
        Stack<Integer> s = new Stack<Integer>();
        //存储链表值
        ArrayList<Integer> data = new ArrayList<Integer>();
        //存储结果值
        ArrayList<Integer> result = new ArrayList<Integer>();

        int index = 0;
        while(head!=null){
            //先对结果当前位置填充上无效值0
            result.add(0);
            //将当前链表值添加到data中
            data.add(head.val);
            while(!s.empty()&&head.val>data.get(s.peek())){
                //栈不为空且当前head.val大于栈顶索引值对应的节点值
                //将s中存储的索引与head.val 对结果result的值进行更新
                result.set(s.pop(),head.val);
            }
            //将当前索引值压栈
            s.push(index);
            index++;

            head = head.next;
        }
        
        int[] resultInt = new int[result.size()];
        for(int i=0;i<result.size();i++){
            resultInt[i] = result.get(i);
        }
        return resultInt;
    }
}