单调栈

//双栈法排序,排序的结果是栈顶最大，栈底最小
    public Stack<Integer> twoStackSort(Stack<Integer>stack){
        Stack<Integer>res = new Stack<>();
        if (stack.isEmpty())return res;
        int temp1 = stack.pop();
        while (!stack.isEmpty()||temp1!=Integer.MIN_VALUE){
            int temp2 = res.isEmpty()?Integer.MIN_VALUE:res.peek();
            if (temp1>=temp2){
                res.push(temp1);
                temp1 = stack.isEmpty()?Integer.MIN_VALUE:stack.pop();  //最后一次出栈，会导致stack为null，所以会丢失temp1的入栈，因此多了||判断
            }
            else {
                stack.push(res.pop());
            }
        }
        return res;
    }
    
    //单调栈找相邻最大的节点
    //输入链表头结点：6->4->7->5->8->2;
    //输出一个数组，代表当前下标位置右边最近一个比他大的值，如果不存在，则为0
    //输出：[7,7,8,8,0,0]
    public int [] nearBigNumber (ListNode head){
        ListNode cur = head;
        int len = 0;
        while (cur!=null){
            len++;
            cur = cur.next;
        }
        int [] res = new int[len];
        Stack<Pair>stack = new Stack<>();
        cur = head;
        int index = 0;
        int temp = Integer.MAX_VALUE;
        while (cur!=null){
            if (temp>=cur.val){
                stack.push(new Pair(index,cur));
                temp = cur.val;
                cur = cur.next;
                index++;
            }else if (!stack.isEmpty()){
                Pair pair = stack.pop();
                temp = pair.node.val;
                if (temp<cur.val){
                    res[pair.index]=cur.val;
                }
                else {
                    stack.push(pair);
                }
            }
            else {
                stack.push(new Pair(index,cur));
                index++;
                temp = cur.val;
                cur = cur.next;
            }
        }
        return res;
    }