leetcode单调栈总结

单调栈是在栈的先进后出基础之上额外添加一个特性：从栈顶到栈底的元素是严格递增（or递减）。动画：什么是单调栈？一文很直观的解释了单调栈并给出了单调递减栈的一个例子，但是上文中误写为单调递增栈。当遇到的问题，和前后元素之间的大小关系有关系时可以考虑使用单调栈。如单调递增栈可以找到左起第一个比当前数字小的元素，单调递减栈可以找到左起第一个比当前数字大的元素。

以单调递减栈为例，每当我们遇到一个比当前栈顶所对应的数大的数的时候，弹出栈内所有比这个数小的栈内元素，而对于每一个元素，当它出栈的时候，说明它遇到了自己的下一个比他大的值。然后将当前数压栈。

496.下一个更大元素1

给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出-1。

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
    对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
    对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
    对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。

输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
    对于num1中的数字2，第二个数组中的下一个较大数字是3。
    对于num1中的数字4，第二个数组中没有下一个更大的数字，因此输出 -1。

首先以简单经典问题距离，该问题是单调栈的直接应用。遍历一次nums2数组，构建单调递减栈即可知道nums2中所有数字下一个更大的数是什么，将这个结果保存在字典中，查询提取即可。

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        // 单调递减栈
        Map<Integer,Integer> map = new HashMap<>();
        Stack<Integer> stack = new Stack<>();
        for(int num:nums2) {
            while(!stack.empty()) {
                if (stack.peek() < num) {
                    map.put(stack.pop(),num);
                } else {
                    break;
                }
            }
            stack.push(num);
        }
        int[] ret = new int[nums1.length];
        for(int i=0;i<nums1.length;i++) {
            if(map.containsKey(nums1[i])) {
                ret[i] = map.get(nums1[i]);
            } else {
                ret[i] = -1;
            }
        }
        return ret;
    }
}

503.下一个更大元素

给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。

输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

本题与上题相比添加了数组可以循环，并且数组中存在重复数字。遍历数组两次即可达到循环的效果，对于重复数字，通过在栈中保存索引来区别是重复数字中的哪一个。

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        // 单调递减栈，存储索引（数字存在重复）
        Stack<Integer> stack = new Stack<>();
        int[] ret = new int[nums.length];
        for(int i=0;i<ret.length;i++) {
            ret[i] = -1;
        }
        for(int i=0;i<2*nums.length - 1;i++) {
            while(!stack.empty()) {
                if(nums[i%nums.length] > nums[stack.peek()]) {
                    ret[stack.pop()] = nums[i%nums.length];
                } else {
                    break;
                }
            }
            stack.push(i%nums.length);
        }
        return ret;
    }
}

42.接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 感谢 Marcos 贡献此图。

示例:

输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6

当找到比当前值大的下一个值后，这个部分可能可以接到雨水，此时需要比较当前值的左端也就是栈顶和比当前值大的下一个值，看看这两个值是否构成接雨水的条件，也就是需要在这两个值中选一个最小值，再减去当前值，就是可以接雨水的高度。宽度使用索引相减即可。

class Solution {
    public int trap(int[] height) {
        // 单调递减栈存储索引
        Stack<Integer> stack = new Stack<>();
        int ret = 0;
        for(int i=0;i<height.length;i++) {
            while(!stack.empty() && height[i] > height[stack.peek()]) {
                int index = stack.pop();
                if (stack.empty()) {
                    break;
                }
                //栈顶和当前为接雨水的两端，index处为低谷
                int distance = i - stack.peek() - 1;  
                int curheight = Math.min(height[i],height[stack.peek()]) - height[index];
                ret += curheight * distance;
            }
            stack.push(i);
        }
        return ret;
    }
}

739.每日温度

根据每日 气温 列表，请重新生成一个列表，对应位置的输入是你需要再等待多久温度才会升高超过该日的天数。如果之后都不会升高，请在该位置用 0 来代替。

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。

提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

是一道典型的单调栈问题。