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

原题链接：

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

https://leetcode.cn/problems/next-greater-node-in-linked-list/description/

完成情况：

解题思路：

class Solution {
// 私有的整型数组result
private int [] result;
// 使用ArrayDeque实现的私有的栈myStack
private final Deque myStack = new ArrayDeque<>();
// 整型变量n

/**
 *
 * @param head
 * @return
 */

…
}

在这段代码中，定义了一个Solution类，包括一个私有的整型数组result、一个使用ArrayDeque实现的私有的栈myStack、以及一个整型变量n。这段代码还包含了一个注释，用于说明该函数的作用以及参数。

参考代码：

_1019链表中的下一个更大节点_逆向出栈

package leetcode板块;

import java.util.ArrayDeque;
import java.util.Deque;

public class _1019链表中的下一个更大节点_逆向出栈 {
    private class ListNode {
          int val;
          ListNode next;
          ListNode() {}
          ListNode(int val) { this.val = val; }
          ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }
    private  int [] result;
    private final Deque<Integer> myStack = new ArrayDeque<>();
    /**
     *
     * @param head
     * @return head链表中，每一个元素都返回其后面比它大的第一个元素即可。
     */
    public int[] nextLargerNodes(ListNode head) {
        //  TODO  从右往左遍历
        //  反向链入，转化成去最小元素，5   ->   3  5    ->   4比3大，把3剔除掉，栈里面保留  4  5
        findNextSmaller(head,0);
        return result;
    }

    /**
     *
     * @param node
     * @param curSite
     */
    private void findNextSmaller(ListNode node, int curSite) {
        if(node == null){
            result = new int[curSite]; //前面为空是，明确数组长度
            return;
        }
        findNextSmaller(node.next, curSite+1);
        //触底之后，找到前一个更大的元素，如果比当前的栈顶元素更大，就把它踢掉，然后继续往下找
        while (!myStack.isEmpty() && myStack.peek() <= node.val){
            myStack.pop();  //弹出无用数据
        }
        if (!myStack.isEmpty()){
            result[curSite] = myStack.peek();   //栈顶就是第i个节点的下一个更大元素
        }
        myStack.push(node.val);
    }
}

_1019链表中的下一个更大节点_反转链表

package leetcode板块;

import java.util.ArrayDeque;
import java.util.Deque;

public class _1019链表中的下一个更大节点_反转链表 {

    private class ListNode {
        int val;
        ListNode next;
        ListNode() {}
        ListNode(int val) { this.val = val; }
        ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    }

    private int [] result;
    private final Deque<Integer> myStack = new ArrayDeque<>();
    private int n;

    /**
     *
     * @param head
     * @return
     */
    public int[] nextLargerNodes(ListNode head){
        head  = reverseList(head);
        //逆向弹出小于当前值的元素，每次读取留在栈顶的元素
        //逆转链表时，会获取到链表的size
        result = new int[n];    //先明确数组长度
        for (ListNode curNode = head; curNode != null; curNode = curNode.next){
            while (!myStack.isEmpty() && myStack.peek() <= curNode.val){
                myStack.pop();  //pass掉比当前数还小的元素
            }
            result[--n] = myStack.isEmpty() ? 0 : myStack.peek();
            myStack.push(curNode.val);  //否则就认为是当前元素，并将之push到栈顶
        }
        return result;
    }

    /**
     *
     * @param head
     * @return
     */
    private ListNode reverseList(ListNode head) {
        ListNode prev = null,cur = head;
        while (cur != null){
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
            ++n;
        }
        return prev;
    }

}

错误经验吸取