Leetcode—单调栈专题(java版本)

---

一、介绍

单调栈是一种特殊的栈。栈本来就是一种受限的数据结构了(后进先出)，单调栈在此基础上又受限了一次。单调栈要求栈中的元素是单调递减或者单调递增的，单调栈用途不太广泛，只处理一种典型的问题，叫做 Next Greater Element。

二、单调栈模板题

739. 每日温度
请根据每日气温列表 temperatures ，请计算在每一天需要等几天才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 0 来代替。
示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]

示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]

示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]

提示：

• 1 <= temperatures.length <= 105
• 30 <= temperatures[i] <= 100

思路：
针对示例1而言，给定列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，为啥输出就是 [1, 1, 4, 2, 1, 1, 0, 0] ？
下面来一个个进行解释。
对于输入 73，它需要 经过一天 才能等到温度的升高，也就是在第二天的时候，温度升高到 74 ，所以对应的结果是 1。
对于输入 74，它需要 经过一天 才能等到温度的升高，也就是在第三天的时候，温度升高到 75 ，所以对应的结果是 1。
对于输入 75，它经过 1 天后发现温度是 71，没有超过它，继续等，一直 等了四天，在第七天才等到温度的升高，温度升高到 76 ，所以对应的结果是 4 。
对于输入 71，它经过 1 天后发现温度是 69，没有超过它，继续等，一直 等了两天，在第六天才等到温度的升高，温度升高到 72 ，所以对应的结果是 2 。
对于输入 69，它 经过一天 后发现温度是 72，已经超过它，所以对应的结果是 1 。
对于输入 72，它 经过一天 后发现温度是 76，已经超过它，所以对应的结果是 1 。
对于输入 76，后续 没有温度 可以超过它，所以对应的结果是 0 。
对于输入 73，后续 没有温度 可以超过它，所以对应的结果是 0 。
好了，理解了题意我们来思考如何求解。
方法一：
第一个想法就是针对每个温度值 向后进行依次搜索 ，找到比当前温度更高的值，这是最容易想到的办法。
其原理是从左到右除了最后一个数其他所有的数都遍历一次，最后一个数据对应的结果肯定是 0，就不需要计算。
遍历的时候，每个数都去向后数，直到找到比它大的数，数的次数就是对应输出的值。

public int[] dailyTemperatures(int[] T) {
    int length = T.length;
    int[] result = new int[length];
    for (int i = 0; i < length; i++) {
        int current = T[i];
        if (current < 100) {
            for (int j = i + 1; j < length; j++) {
                if (T[j] > current) {
                    result[i] = j - i;
                    break;
                }
            }
        }
    }
    return result;
}

不难看出，复杂度是O(n^2)，那么有没有复杂度低的解决方法呢，答案是有的，那就是使用单调栈，而且还是递减栈(栈里只有递减元素)。
方法二：
遍历整个数组，如果栈不空，且当前数字大于栈顶元素，那么如果直接入栈的话就不是 递减栈 ，所以需要取出栈顶元素，由于当前数字大于栈顶元素的数字，而且一定是第一个大于栈顶元素的数，直接求出下标差就是二者的距离。
继续看新的栈顶元素，直到当前数字小于等于栈顶元素停止，然后将数字入栈，这样就可以一直保持递减栈，且每个数字和第一个大于它的数的距离也可以算出来。

    public int[] dailyTemperatures(int[] temperatures) {
        int[] res = new int[temperatures.length];
        Stack<Integer> stack = new Stack<>();
        for (int i = temperatures.length - 1; i >= 0; i--) {
            while (!stack.isEmpty() && (temperatures[i] >= temperatures[stack.peek()])) {
                stack.pop();
            }
            res[i] = stack.empty() ? 0 : stack.peek() - i;
            stack.push(i);
        }
        return res;
    }

分析复杂度的时候，有朋友一看for里面套了个while，就说复杂度是$O(n^2)$，但其实，该方法只需要对数组进行一次遍历，每个元素最多被压入和弹出堆栈一次，所以算法复杂度是$O(N)$。 由于使用了栈， 并且栈的长度最大是和 arr 长度一致，因此空间复杂度是 $O(N)$，其中 N 为数组长度。

三、总结

这个算法的过程用一句话总结就是，如果压栈之后仍然可以保持单调性，那么直接压。否则先弹出栈的元素，直到压入之后可以保持单调性。 这个算法的原理用一句话总结就是，被弹出的元素都是大于当前元素的，并且由于栈是单调增的，因此在其之后小于其本身的最近的就是当前元素了。

四、推荐题目

42.接雨水
84.柱状图中最大的矩形
739.每日温度
316. 去除重复字母（困难）
402. 移掉K位数字
496. 下一个更大元素 I（简单）
581. 最短无序连续子数组
901. 股票价格跨度（中等）