单调栈学习总结

1、单调栈用来做什么？

栈内的元素满足单调性，可以以O(n)的时间复杂度解决比如在一维数组中对每一个数找到第一个小于自己的元素等问题。

2、单调栈的使用

2.1 基本需求

在一维数组中对每一个数找到第一个小于自己的元素，如果没有，返回-1

代码实现如下：

public int[] findMinLeft(int[] nums){
        int len = nums.length;
        int[] res = new int[len];
        res[0] = -1;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        for (int i = 1; i < len; i++) {
            int num = nums[i];
            while (!stack.isEmpty()){
                int tmp = stack.peek();
                //如果栈顶元素大于等于num，将其出栈，表示不满足要求，且在后续元素的寻找中也不会考虑该栈顶元素，因为num已经拦在中间了
                if (nums[tmp] >= num){
                    stack.pop();
                }else{
                    res[i] = tmp;
                    stack.push(i);
                    break;
                }
            }
            //如果栈为空了说明没有找到小于nums[i]的元素，res[i]赋值为-1，将当前元素入栈
            if (stack.isEmpty()) {
                res[i] = -1;
                stack.push(i);
            }
        }
        return res;
    }

2.2 进阶需求

在一维数组中对每一个数找到左边最接近自己的且小于等于自己的元素的下标，若没有，则返回-1并且在此过程中找到右边最接近自己的且小于自己的元素的下标，若没有，则返回len，将后者返回。

代码实现如下：

public int[] findMinRight(int[] nums){
        int len = nums.length;
        int[] res = new int[len];
        int[] pos = new int[len];
        Arrays.fill(pos, len);
        res[0] = -1;
        Stack<Integer> stack = new Stack<>();
        stack.push(0);
        for (int i = 1; i < len; i++) {
            int num = nums[i];
            while (!stack.isEmpty()){
                int tmp = stack.peek();
                if (nums[tmp] > num){
                    pos[tmp] = i;
                    stack.pop();
                }else{
                    res[i] = tmp;
                    stack.push(i);
                    break;
                }
            }
            if (stack.isEmpty()) {
                res[i] = -1;
                stack.push(i);
            }
        }
        System.out.println(Arrays.toString(res));
        return pos;
    }

2.3 实战需求

84. 柱状图中最大的矩形
该问题是2.2节的一个现实版本，代码表示如下：

class Solution {
    public int largestRectangleArea(int[] heights) {
        int res = 0;
        Deque<Integer> stack = new ArrayDeque<>();
        int[] new_heights = new int[heights.length + 2];
        for (int i = 1; i < heights.length + 1; i++) {
            new_heights[i] = heights[i - 1];
        }
        for (int i = 0; i < new_heights.length; i++) {
            while (!stack.isEmpty() && new_heights[stack.peek()] > new_heights[i]) {
                int cur = stack.pop();
                int l = stack.peek();
                int r = i;
                res = Math.max(res, (r - l - 1) * new_heights[cur]);
            }
            stack.push(i);
        }
        return res;
    }
}