算法-单调栈

单调栈

题目

在力扣刷算法题时刷到这道题，觉得涉及到的算法很有意思。

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

例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/daily-temperatures
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

暴力解法

class Solution {
    public int[] dailyTemperatures(int[] T) {
        //获取列表长度，实例化一个同长度的数组
        int length = 0;
        length = T.length;
        int[] days = new int[length];
        
        //二重循环，逐个元素往后面比较
        int i,j;
        int currt,temp;
        for(i=0;i<length;i++){
            currt=T[i];
            days[i]=0;
            for(j=i+1;j<length;j++){
                temp=T[j];
                if(temp>currt){
                    days[i]=j-i;
                    break;
                }
            }
        }
        return days;
    }
}

执行结果

执行用时 :230 ms, 在所有 java 提交中击败了31.80% 的用户

内存消耗 :41 MB, 在所有 java 提交中击败了97.16%的用户

• 相信大部分人都能够想到该种解法，但是可以看出用时方面是非常不理想的，时间复杂度为O(n²)。

分析

可以知道数组在遍历的时候中间的数组可能会进行多次遍历，我们要做的就是减少元素的遍历次数。那么有没有一种算法是可以让遍历过的元素不用再多次遍历，或者是每个元素只遍历一次呢？答案是有的，那就是本篇文章的核心：单调栈。

单调栈的定义

单调栈就是栈内元素单调递增或者递减的栈，这里的单调递增或递减是指的从栈顶到栈底单调递增或递减，即出栈的顺序。每个元素都要入栈，且仅入栈一次，出栈后不再入栈。

如：数组array【15,12,14,33,19】，栈stack【】

1. 从左到右第一个数15，由于栈是空的，15可以入栈，此时stack【15】
2. 第二个数12，栈顶元素为15，12<15，12可以入栈，此时stack【15，12】
3. 第三个数14，栈顶元素为12，14>12，14暂时不可以入栈，需要进行单调栈维护
   1. 栈顶元素12出栈，此时stack【15】，栈顶元素为15，14<15，14可以入栈，此时stack【15，14】
4. 第四个数33，栈顶元素为14，33>14，33暂时不可以入栈，需要进行单调栈维护
   1. 栈顶元素14出栈，此时stack【15】，栈顶元素为15，33>15，33仍不可以入栈
   2. 栈顶元素15出栈，此时栈为空，33可以入栈，此时stack【33】
5. 第五个数19，栈顶元素为33，19<33，19可以入栈，此时stack【33，19】
6. 最后形成的单调栈为stack【33，19】

单调递增栈解法

可以知道对于一个单调递增栈来说，栈顶元素一定最小的，当遇上大于栈顶元素的元素，不能直接入栈时，可以知道该元素一定是第一个大于栈顶元素的元素，所以可以用单调递增栈解决该问题。

class Solution {
    public int[] dailyTemperatures(int[] T) {
        //获取列表长度，实例化一个同长度的数组
        int length = T.length;
        int[] days = new int[length];
        Stack<Integer> st = new Stack<Integer>();
        //单调递增栈
        int i,temp;
        for(i=0;i<length;i++){
            days[i]=0;
            //维护单调栈
            while(!st.empty()&&T[st.peek()]<T[i]){
                temp = st.pop();
                days[temp]=i-temp;
            }
            st.push(i);
        }
        return days;
    }
}

执行结果

执行用时 :55 ms, 在所有 java 提交中击败了70.89% 的用户

内存消耗 :41.9 MB, 在所有 java 提交中击败了95.19%的用户

• 可以看出该算法虽然内存消耗略有增加，但是在执行用时上有了很大的进步，该算法的时间复杂度为O(n)。

• 用单调递减栈也能够实现相同的效果，只不过要逆序入栈，有兴趣的读者可以自行实验。

单调栈的应用

• 单调递增栈可以找到左起第一个比当前数字小的元素。
• 单调递减栈可以找到左起第一个比当前数字大的元素。

这些只是单调栈最基本的应用，笔者稍后会继续更新单调栈的应用。