题目对“下一个更高”或者“下一个更低”有要求，可以考虑单调栈

（也可以考虑双指针，双指针往往能够把时间复杂度的指数减一）

1.739. 每日温度

思路

首先想到的当然是暴力解法，两层for循环，把至少需要等待的天数就搜出来了。时间复杂度是O(n^2)

那么接下来在来看看使用单调栈的解法。

什么时候用单调栈呢？

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。时间复杂度为O(n)。

例如本题其实就是找找到一个元素右边第一个比自己大的元素，此时就应该想到用单调栈了。

单调栈的原理是什么呢？为什么时间复杂度是O(n)就可以找到每一个元素的右边第一个比它大的元素位置呢？

单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。

更直白来说，就是用一个栈来记录我们遍历过的元素，因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我们需要用一个容器（这里用单调栈）来记录我们遍历过的元素。

在使用单调栈的时候首先要明确如下几点：

1.单调栈里存放的元素是什么？

单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取。

2.单调栈里元素是递增呢？ 还是递减呢？

本题中，我们要求的是“下一个更大”，当新元素大于栈内元素时，我们知道新元素就是站内比它小的元素的“下一个更大”，所以只有新元素小于栈顶元素时才可以入栈，维护的是栈顶到栈底非严格递增的栈。

使用单调栈主要有三个判断条件。

• 当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
• 当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
• 当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况

把这三种情况分析清楚了，也就理解透彻了。

本题图解参考：739每日温度单调栈图解

单调栈递增（从栈口到栈底顺序），就是求右边第一个比自己大的，单调栈递减的话，就是求右边第一个比自己小的。

代码如下：

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int[] result = new int[temperatures.length];
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(0);
        for(int i = 1 ; i < temperatures.length ;i++){
            if(temperatures[stack.peek()] >= temperatures[i]){
                stack.push(i);
            }else{
                while(!stack.isEmpty() && temperatures[stack.peek()]< temperatures[i]){
                    result[stack.peek()] = i - stack.pop();
                }
                stack.push(i);
            }
        }

        while(!stack.isEmpty()){
            result[stack.pop()] = 0;
        }
        return result;
    }
}

2.496.下一个更大元素 I

暴力搜索：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] res = new int[nums1.length];
        for(int i = 0 ; i < nums1.length ; i++){
            res[i] = -1;
        }
        for(int i = 0 ; i < nums1.length ; i++){
            for(int j = 0 ; j < nums2.length ; j++){
                if(nums1[i] == nums2[j]){
                    for(int k = j+1 ; k < nums2.length ; k++){
                        if(nums1[i] < nums2[k]){
                            res[i] = nums2[k];
                            break;
                        }
                    }
                    break;
                }
            }
        }
        return res;
    }
}

由于题目要求求的是“下一个更大”，考虑使用单调栈降低时间复杂度

从题目示例中我们可以看出最后是要求nums1的每个元素在nums2中下一个比当前元素大的元素，那么就要定义一个和nums1一样大小的数组result来存放结果。

这个result数组初始化应该为多少呢？

题目说如果不存在对应位置就输出 -1 ，所以result数组如果某位置没有被赋值，那么就应该是是-1，所以就初始化为-1。

在遍历nums2的过程中，我们要判断nums2[i]是否在nums1中出现过，因为最后是要根据nums1元素的下标来更新result数组。

注意题目中说是两个没有重复元素 的数组 nums1 和 nums2。

没有重复元素，我们就可以用map来做映射了。根据数值快速找到下标，还可以判断nums2[i]是否在nums1中出现过。

使用单调栈的思路和纯使用单调栈寻找“下一个更大”一样，只是这一次在填写答案的时候，先检查要填写的数字是否在nums1里，如果有，就填写，如果没有就不用填写。

代码如下：

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer,Integer> map = new HashMap<>();
        Deque<Integer> stack = new ArrayDeque<>();
        int[] res = new int[nums1.length];
        for(int i = 0 ; i < nums1.length ;i++){
            res[i] = -1;
        }
        for(int i = 0; i < nums1.length ; i++){
            map.put(nums1[i],i);
        }
        stack.push(0);
        for(int i = 1 ; i < nums2.length ; i++){
            //仍然像正常遍历求nextBigger一样维护单调栈
            //但是在出栈（填写答案）的时候判断是不是nums1里的元素即可
            while(!stack.isEmpty() && nums2[stack.peek()] < nums2[i]){
                if(map.containsKey(nums2[stack.peek()])){
                    res[map.get(nums2[stack.peek()])] = nums2[i];
                }
                stack.pop();
            }
            stack.push(i);
        }
        return res;
    }
}

3.503.下一个更大元素II

思路：既然是循环，那么把原来的操作进行一遍后，再来一遍，就可以得到循环的结果。

代码如下：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int[] res = new int[nums.length];
        Deque<Integer> stack = new ArrayDeque<>();
        for(int i = 0 ; i < nums.length ;i++){
            res[i] = -1;
        }
        stack.push(0);
        for(int i = 0; i < nums.length ;i++){
            if(nums[stack.peek()] < nums[i]){
                while(!stack.isEmpty() && nums[stack.peek()] < nums[i]){
                    res[stack.peek()] = nums[i];
                    stack.pop();
                }
            }
            stack.push(i);
        }

        for(int i = 0; i < nums.length ;i++){
            if(nums[stack.peek()] < nums[i]){
                while(!stack.isEmpty() && nums[stack.peek()] < nums[i]){
                    res[stack.peek()] = nums[i];
                    stack.pop();
                }
            }
            stack.push(i);
        }
        return res;
    }
}

精简版本：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int[] res = new int[nums.length];
        Deque<Integer> stack = new ArrayDeque<>();
        for(int i = 0 ; i < nums.length ;i++){
            res[i] = -1;
        }
        stack.push(0);
        for(int i = 0; i < nums.length*2 ;i++){
            if(nums[stack.peek()] < nums[i%nums.length]){
                while(!stack.isEmpty() && nums[stack.peek()] < nums[i%nums.length]){
                    res[stack.peek()] = nums[i%nums.length];
                    stack.pop();
                }
            }
            stack.push(i%nums.length);
        }
        return res;
    }
}

4.42. 接雨水

思路1：前后缀

根据本题要求的物理特性，把每一个格子看成一个独立的水桶，它能盛多少水取决于水桶左右的最小高度。因此我们要计算出它的右边的最大和左边的最大，在这两个最大中取最小，再减去地基的高度，这就是这个水桶能盛水的数量。

暴力模拟（会时间超限，时间复杂度O(n^2)：

class Solution {
    public int trap(int[] height) {
        int res = 0;
        for(int i = 0; i < height.length ;i++){
            if(i == 0 || i == height.length-1) continue;
            int left = height[i] , right = height[i];
            for(int j = i-1 ; j >= 0 ; j--){
                left = Math.max(left,height[j]);
            }
            for(int j = i+1 ; j < height.length ;j++){
                right = Math.max(right,height[j]);
            }
            res += (Math.min(left,right)-height[i]);
        }
        return res;
    }
}

思路2：考虑使用双指针求前后缀降低时间复杂度：

class Solution {
    public int trap(int[] height) {
        int[] maxLeft = new int[height.length];
        maxLeft[0] = height[0];
        int[] maxRight = new int[height.length];
        maxRight[height.length-1] = height[height.length-1];
        for(int i = 1; i < height.length ; i++){
            maxLeft[i] = Math.max(height[i],maxLeft[i-1]);
        }
        for(int i = height.length-2 ; i >= 0 ; i--){
            maxRight[i] = Math.max(maxRight[i+1],height[i]);
        }
        int result = 0;
        for(int i = 0 ; i < height.length ; i++){
            result += (Math.min(maxLeft[i],maxRight[i]) - height[i]);
        }
        return result;

    }
}

这里的思想是考虑到maxLeft 和 maxRight 的计算存在重复，因此使用了 maxLeft 和 maxRight两个数组来记录已经计算过的结果。同时也用到了动态规划的思想，使用记录过的已经计算过的结果来得到新的要计算的结果，需要考虑遍历顺序和初始化的问题。

思路3：单调栈

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，就可以考虑用单调栈了。

1.单调栈的解题思路以行的方式考虑雨水累加，这样一层层计算，层的宽度与 当前下标 和 下一个更高的下标 有关，层高与 Math.min（左高，右高） - 底高 有关。

2.使用单调栈内元素的顺序：

从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。

因为一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。

如图：

3.遇到相同的元素

遇到相同的元素，更新栈内下标，就是将栈里元素（旧下标）弹出，将新元素（新下标）加入栈中。

例如 5 5 1 3 这种情况。如果添加第二个5的时候就应该将第一个5的下标弹出，把第二个5添加到栈中。

因为我们要求宽度的时候 如果遇到相同高度的柱子，需要使用最右边的柱子来计算宽度。

如图所示：

4.栈里存放什么元素

使用单调栈，也是通过 长 * 宽 来计算雨水面积的。

长就是通过柱子的高度来计算，宽是通过柱子之间的下标来计算，

栈里就存放下标就行，想要知道对应的高度，通过height[stack.top()] 就知道弹出的下标对应的高度了。

单调栈处理逻辑

以下操作过程其实和 739. 每日温度 (opens new window)也是一样的，建议先做 739. 每日温度 (opens new window)。

以下逻辑主要就是三种情况

• 情况一：当前遍历的元素（柱子）高度小于栈顶元素的高度 height[i] < height[st.top()]
• 情况二：当前遍历的元素（柱子）高度等于栈顶元素的高度 height[i] == height[st.top()]
• 情况三：当前遍历的元素（柱子）高度大于栈顶元素的高度 height[i] > height[st.top()]

先将下标0的柱子加入到栈中，st.push(0);。 栈中存放我们遍历过的元素，所以先将下标0加进来。

然后开始从下标1开始遍历所有的柱子，for (int i = 1; i < height.size(); i++)。

如果当前遍历的元素（柱子）高度小于栈顶元素的高度，就把这个元素加入栈中，因为栈里本来就要保持从小到大的顺序（从栈头到栈底）。

代码如下：

if (height[i] < height[st.top()])  st.push(i);

如果当前遍历的元素（柱子）高度等于栈顶元素的高度，要跟更新栈顶元素，因为遇到相相同高度的柱子，需要使用最右边的柱子来计算宽度。

代码如下：

if (height[i] == height[st.top()]) { // 例如 5 5 1 7 这种情况
  st.pop();
  st.push(i);
}

如果当前遍历的元素（柱子）高度大于栈顶元素的高度，此时就出现凹槽了，如图所示：

取栈顶元素，将栈顶元素弹出，这个就是凹槽的底部，也就是中间位置，下标记为mid，对应的高度为height[mid]（就是图中的高度1）。

此时的栈顶元素st.top()，就是凹槽的左边位置，下标为st.top()，对应的高度为height[st.top()]（就是图中的高度2）。

当前遍历的元素i，就是凹槽右边的位置，下标为i，对应的高度为height[i]（就是图中的高度3）。

此时大家应该可以发现其实就是栈顶和栈顶的下一个元素以及要入栈的元素，三个元素来接水！

那么雨水高度是 min(凹槽左边高度, 凹槽右边高度) - 凹槽底部高度，代码为：int h = min(height[st.top()], height[i]) - height[mid];

雨水的宽度是 凹槽右边的下标 - 凹槽左边的下标 - 1（因为只求中间宽度），代码为：int w = i - st.top() - 1 ;

当前凹槽雨水的体积就是：h * w。

求当前凹槽雨水的体积代码如下：

while (!st.empty() && height[i] > height[st.top()]) { // 注意这里是while，持续跟新栈顶元素
    int mid = st.top();
    st.pop();
    if (!st.empty()) {
        int h = min(height[st.top()], height[i]) - height[mid];
        int w = i - st.top() - 1; // 注意减一，只求中间宽度
        sum += h * w;
    }
}

逻辑详细的完整代码如下：

class Solution {
    public int trap(int[] height) {
    //横向切分，思路是单调栈，注意下一个元素与当前栈顶元素 因 大小不同 造成的不同逻辑
        int sum = 0;
        Deque<Integer> stack = new ArrayDeque<>();//存放下标，如果要取高度，则用height取
        stack.push(0);
        for(int i = 1; i < height.length ; i++){
            if(height[stack.peek()] > height[i]){
                stack.push(i);
            }else if(height[stack.peek()] == height[i]){
                stack.pop();
                stack.push(i);
            }else{
                while(!stack.isEmpty() && height[stack.peek()] < height[i]){
                    int mid = stack.pop();
                    int right = i;
                    if(!stack.isEmpty()){
                        int left = stack.peek();
                        int w = right - left - 1;
                        int h = Math.min(height[right],height[left]) - height[mid];
                        sum += h*w;
                    }
                }
                stack.push(i);
            }

        }
        return sum;
    }
}

对重复的地方进行优化；

class Solution {
    public int trap(int[] height) {
    //横向切分，思路是单调栈，注意下一个元素与当前栈顶元素 因 大小不同 造成的不同逻辑
        int sum = 0;
        Deque<Integer> stack = new ArrayDeque<>();//存放下标，如果要取高度，则用height取
        stack.push(0);
        for(int i = 1; i < height.length ; i++){
            if(height[stack.peek()] == height[i]){
                stack.pop();
            }else if(height[stack.peek()] < height[i]){
                while(!stack.isEmpty() && height[stack.peek()] < height[i]){
                    int mid = stack.pop();
                    int right = i;
                    if(!stack.isEmpty()){
                        int left = stack.peek();
                        int w = right - left - 1;
                        int h = Math.min(height[right],height[left]) - height[mid];
                        sum += h*w;
                    }
                }
            }
            stack.push(i);
        }
        return sum;
    }
}

5.84.柱状图中最大的矩形

暴力解法

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int sum = 0;
        for (int i = 0; i < heights.size(); i++) {
            int left = i;
            int right = i;
            for (; left >= 0; left--) {
                if (heights[left] < heights[i]) break;
            }
            for (; right < heights.size(); right++) {
                if (heights[right] < heights[i]) break;
            }
            int w = right - left - 1;
            int h = heights[i];
            sum = max(sum, w * h);
        }
        return sum;
    }
};

如上代码并不能通过leetcode，超时了，因为时间复杂度是$O(n^2)$。

双指针法

（但是时间复杂度仍然是O(n^2)）量级：

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        vector<int> minLeftIndex(heights.size());
        vector<int> minRightIndex(heights.size());
        int size = heights.size();

        // 记录每个柱子 左边第一个小于该柱子的下标
        minLeftIndex[0] = -1; // 注意这里初始化，防止下面while死循环
        for (int i = 1; i < size; i++) {
            int t = i - 1;
            // 这里不是用if，而是不断向左寻找的过程
            while (t >= 0 && heights[t] >= heights[i]) t = minLeftIndex[t];
            minLeftIndex[i] = t;
        }
        // 记录每个柱子 右边第一个小于该柱子的下标
        minRightIndex[size - 1] = size; // 注意这里初始化，防止下面while死循环
        for (int i = size - 2; i >= 0; i--) {
            int t = i + 1;
            // 这里不是用if，而是不断向右寻找的过程
            while (t < size && heights[t] >= heights[i]) t = minRightIndex[t];
            minRightIndex[i] = t;
        }
        // 求和
        int result = 0;
        for (int i = 0; i < size; i++) {
            int sum = heights[i] * (minRightIndex[i] - minLeftIndex[i] - 1);
            result = max(sum, result);
        }
        return result;
    }
};

单调栈

寻找leftNextLow 和 rightNextLow;

分别存放i对应的左边第一个更小元素位置 和 右边第一个更小元素位置；

注意遍历顺序和初始化：

leftNextLow初始化成 -1 (可以认为是没有更小的情况下，-1的位置没有元素，高度是0，是左边第一个更小元素的位置），从右往左遍历。

同理， rightNextLow初始化成 height.length ，从左往右遍历。

遍历，取最大的 height[i] * (rightNextLow[i] - leftRightLow[i] - 1);

class Solution {
    public static int largestRectangleArea(int[] heights) {
        int res = 0;
        int[] leftNextLow = new int[heights.length];
        for(int i = 0; i < heights.length ; i++){
            leftNextLow[i] = -1;
        }
        int[] rightNextLow = new int[heights.length];
        for(int i = 0 ; i < heights.length ; i++){
            rightNextLow[i] = heights.length;
        }
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(0);
        for(int i = 1 ; i < heights.length ; i++){
            while(!stack.isEmpty() && heights[stack.peek()] > heights[i]){
                rightNextLow[stack.peek()] = i;
                stack.pop();
            }
            stack.push(i);
        }

        while(!stack.isEmpty()) stack.pop();
        stack.push(heights.length-1);
        for(int i = heights.length - 2 ; i >= 0 ; i--){
            while(!stack.isEmpty() && heights[stack.peek()] > heights[i]){
                leftNextLow[stack.peek()] = i;
                stack.pop();
            }
            stack.push(i);
        }

        for(int i = 0; i < heights.length ; i++){
            int w = rightNextLow[i] - leftNextLow[i] - 1;
            int h = heights[i];
            res = Math.max(res,w*h);
        }
        return res;
    }
}