专题十：单调栈

声明：

参考： 代码随想录

个人总结归纳，仅用于复习回顾，不作他用！如发现文章内容有误，恳请批评指出！ 

目录

1、什么时候用单调栈？

2、单调栈的原理？ 

3、单调栈注意事项 

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

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

（3）单调栈的三个判断条件 

相关习题： 

 例1：739. 每日温度 - 力扣（LeetCode）

例2：496. 下一个更大元素 I - 力扣（LeetCode） 

 例3：503. 下一个更大元素 II - 力扣（LeetCode）

例4： 42. 接雨水 - 力扣（LeetCode）

 例5：84. 柱状图中最大的矩形 - 力扣（LeetCode）

 

1、什么时候用单调栈？

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

2、单调栈的原理？ 

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

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

3、单调栈注意事项 

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

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

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

（从栈头到栈底的顺序）如果求一个元素右边第一个更大元素，单调栈就是递增的，如果求一个元素右边第一个更小元素，单调栈就是递减的。

（3）单调栈的三个判断条件 

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

相关习题： 

 例1：739. 每日温度 - 力扣（LeetCode）

 

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        stack<int> st;
        vector<int> result(temperatures.size(), 0);
        st.push(0);
        for (int i = 0; i < temperatures.size(); i++) {
            if (temperatures[i] < temperatures[st.top()]) {// 情况一
                st.push(i);
            } else if (temperatures[i] == temperatures[st.top()]) {//情况二
                st.push(i);
            } else {
                while (!st.empty() && temperatures[i] > temperatures[st.top()]) {//情况三
                    result[st.top()] = i - st.top();
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};
//单调栈
//时间复杂度O(n)
//空间复杂度O(n)

 分析：

 步骤一：首先先将第一个遍历元素加入单调栈

 步骤二：加入T[1] = 74，因为T[1] > T[0]（当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况）。

我们要保持一个递增单调栈（从栈头到栈底），所以将T[0]弹出，T[1]加入，此时result数组可以记录了，result[0] = 1，即T[0]右面第一个比T[0]大的元素是T[1]。

 步骤三：加入T[2]，同理，T[1]弹出

 步骤四：加入T[3]，T[3] < T[2] （当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况），加T[3]加入单调栈。

 步骤五：加入T[4]，T[4] == T[3] （当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况），此时依然要加入栈，不用计算距离，因为我们要求的是右面第一个大于本元素的位置，而不是大于等于！

 步骤六：加入T[5]，T[5] > T[4] （当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），将T[4]弹出，同时计算距离，更新result

 步骤七：T[4]弹出之后， T[5] > T[3] （当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况），将T[3]继续弹出，同时计算距离，更新result

 步骤八：直到发现T[5]小于T[st.top()]，终止弹出，将T[5]加入单调栈

 步骤九：加入T[6]，同理，需要将栈里的T[5]，T[2]弹出

 步骤十：同理，继续弹出

 步骤十一：此时栈里只剩下了T[6]

 步骤十二：加入T[7]， T[7] < T[6] 直接入栈，这就是最后的情况，result数组也更新完了。

result[6] , result[7]没更新，元素也一直在栈里。

因为在定义result数组的时候，初始化为0，如果result没有更新，说明这个元素右面没有更大的了，也就是为0。

以上在图解的时候，详细分析了以下三种情况：

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

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

代码精简版：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        stack<int> st;
        vector<int> result(temperatures.size(), 0);
        st.push(0);
        for (int i = 0; i < temperatures.size(); i++) {
            while (!st.empty() && temperatures[i] > temperatures[st.top()]) {
                result[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);
        }
        return result;
    }
};

例2：496. 下一个更大元素 I - 力扣（LeetCode） 

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> st;
        vector<int> result(nums1.size(), -1);
        if(nums1.size() == 0) return result;
        unordered_map<int, int> umap;// key:下标元素，value：下标
        for (int i = 0; i < nums1.size(); i++) {
            umap[nums1[i]] = i;
        }
        st.push(0);
        for (int i = 1; i < nums2.size(); i++) {
            if (nums2[i] < nums2[st.top()]) { // 情况一
                st.push(i);
            } else if (nums2[i] == nums2[st.top()]) { // 情况二
                st.push(i);
            } else {                                  // 情况三
                while (!st.empty() && nums2[i] > nums2[st.top()]) {
                    if (umap.count(nums2[st.top()]) > 0) {// 看map里是否存在这个元素
                        int index = umap[nums2[st.top()]]; // 根据map找到nums2[st.top()] 在 nums1中的下标
                        result[index] = nums2[i];
                    }
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};
//单调栈
//时间复杂度O(n)
//空间复杂度O(n)

 分析：

在 例1：739. 每日温度 - 力扣（LeetCode）中要求每个元素下一个比当前元素大的元素的位置。

而本题要求nums1 是 nums2的子集，找nums1中的元素在nums2中下一个比当前元素大的元素。 

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

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

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

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

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

unordered_map<int, int> umap; // key:下标元素，value：下标
for (int i = 0; i < nums1.size(); i++) {
    umap[nums1[i]] = i;
}

步骤四： 单调栈按栈头到栈底的顺序，要从小到大，也就是保持栈里的元素为递增顺序。只要保持递增，才能找到右边第一个比自己大的元素。

步骤五：分三种情况进行分析：

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

此时满足递增栈（栈头到栈底的顺序），所以直接入栈。

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

如果相等的话，依然直接入栈，因为我们要求的是右边第一个比自己大的元素，而不是大于等于！

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

此时如果入栈就不满足递增栈了，这也是找到右边第一个比自己大的元素的时候。

判断栈顶元素是否在nums1里出现过，（注意栈里的元素是nums2的元素），如果出现过，开始记录结果。

注意：此时栈顶元素在nums2数组中右面第一个大的元素是nums2[i]（即当前遍历元素）。 

while (!st.empty() && nums2[i] > nums2[st.top()]) {
    if (umap.count(nums2[st.top()]) > 0) { // 看map里是否存在这个元素
        int index = umap[nums2[st.top()]]; // 根据map找到nums2[st.top()] 在 nums1中的下标
        result[index] = nums2[i];
    }
    st.pop();
}
st.push(i);

代码精简版：

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> st;
        vector<int> result(nums1.size(), -1);
        if(nums1.size() == 0) return result;
        unordered_map<int, int> umap;
        st.push(0);
        for (int i = 0; i < nums1.size(); i++) {
            umap[nums1[i]] = i;
        }
        for (int i = 1; i < nums2.size(); i++) {
            while (!st.empty() && nums2[i] > nums2[st.top()]) {
                if (umap.count(nums2[st.top()]) > 0) {
                    int index = umap[nums2[st.top()]];
                    result[index] = nums2[i];
                }
                st.pop();
            }
            st.push(i);
        }
        return result;
    }
};

 例3：503. 下一个更大元素 II - 力扣（LeetCode）

 

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(), -1);
        if (nums.size() == 0) return result;
        stack<int> st;
        st.push(0);
        for (int i = 1; i < nums.size() * 2; i++) {
            // 模拟遍历两遍nums，注意一下都是用i % nums.size()来操作
            if (nums[i % nums.size()] < nums[st.top()]) {
                st.push(i % nums.size());
            } else if (nums[i % nums.size()] == nums[st.top()]) {
                st.push(i % nums.size());
            } else {
                while (!st.empty() && nums[i % nums.size()] > nums[st.top()]) {
                    result[st.top()] = nums[i % nums.size()];
                    st.pop();
                }
                st.push(i % nums.size());
            }
        }
        return result;
    }
};
//单调栈
//时间复杂度O(n)
//空间复杂度O(n)

分析：

本题的解题思路与  例1：739. 每日温度 - 力扣（LeetCode）和

例2：496. 下一个更大元素 I - 力扣（LeetCode） 类似，关键在于如何处理循环数组。

在不扩充nums数组的情况下，可以在遍历的过程中模拟走了两遍nums。 

注意：都是用 i % nums.size() 来操作。

代码精简版： 

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(), -1);
        if (nums.size() == 0) return result;
        stack<int> st;
        st.push(0);
        for (int i = 1; i < nums.size() * 2; i++) {
            while (!st.empty() && nums[i % nums.size()] > nums[st.top()]) {
                result[st.top()] = nums[i % nums.size()];
                st.pop();
            }
            st.push(i % nums.size());
        }
        return result;
    }
};

例4： 42. 接雨水 - 力扣（LeetCode）

 

 

解法一：双指针 

class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() <= 2) return 0;
        vector<int> maxLeft(height.size(), 0);
        vector<int> maxRight(height.size(), 0);
        int size = maxRight.size();

        // 记录每个柱子左边柱子最大高度
        maxLeft[0] = height[0];
        for (int i = 1; i < size; i++) {
            maxLeft[i] = max(height[i], maxLeft[i - 1]);
        }
        // 记录每个柱子右边柱子最大高度
        maxRight[size - 1] = height[size - 1];
        for (int i = size - 2; i >= 0; i--) {
            maxRight[i] = max(height[i], maxRight[i + 1]);
        }
        // 求和
        int sum = 0;
        for (int i = 0; i < size; i++) {
            int count = min(maxLeft[i], maxRight[i]) - height[i];
            if (count > 0) sum += count;
        }
        return sum;
    }
};
//双指针
//时间复杂度O(n)
//空间复杂度O(n)

 分析：

按照列来计算，宽度为1，再将每一列的雨水高度求出来即可。

每一列雨水的高度，取决于，该列 左侧最高的柱子和右侧最高的柱子中最矮的那个柱子的高度。

当前列雨水面积：min(左边柱子的最高高度，记录右边柱子的最高高度) - 当前柱子高度。

从头遍历一遍所有的列，然后求出每一列雨水的体积，相加之后就是总雨水的体积。 

为了得到两边的最高高度，使用了双指针来遍历，每到一个柱子都向两边遍历一遍，这其实是有重复计算的。我们把每一个位置的左边最高高度记录在一个数组上（maxLeft），右边最高高度记录在一个数组上（maxRight），这样就避免了重复计算。

当前位置，左边的最高高度是前一个位置的左边最高高度和本高度的最大值。

即从左向右遍历：maxLeft[i] = max(height[i], maxLeft[i - 1]);

从右向左遍历：maxRight[i] = max(height[i], maxRight[i + 1]);

解法二：单调栈 

class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() <= 2) return 0;// 可以不加
        stack<int> st;     // 存着下标，计算的时候用下标对应的柱子高度
        st.push(0);
        int sum = 0;
        for (int i = 1; i < height.size(); i++) {
            if (height[i] < height[st.top()]) {        // 情况一
                st.push(i);
            } else if (height[i] == height[st.top()]) {// 情况二
                st.pop();// 其实这一句可以不加，效果是一样的，但处理相同的情况的思路却变了。
                st.push(i);
            } else {                                   // 情况三
                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;
                    }
                }
                st.push(i);
            }
        }
        return sum;
    }
};
//单调栈
//时间复杂度O(n)
//空间复杂度O(n)

 分析：

步骤一：单调栈是按照行方向来计算雨水，如图：

 步骤二：单调栈内元素从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。

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

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

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

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

步骤四：分析三种逻辑情况

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

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

代码如下：

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

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

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

  代码如下：

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

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

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

 取栈顶元素，将栈顶元素弹出，这个就是凹槽的底部，也就是中间位置，下标记为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(vector<int>& height) {
        if (height.size() <= 2) return 0;
        stack<int> st;
        st.push(0);
        int sum = 0;
        for (int i = 1; i <height.size(); i++) {
            while (!st.empty() && height[i] > height[st.top()]) {
                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;
                }
            }
            st.push(i);
        }
        return sum;
    }
};

 例5：84. 柱状图中最大的矩形 - 力扣（LeetCode）

 

 解法一：双指针

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;
    }
};
//双指针
//时间复杂度O(n)
//空间复杂度O(n)

分析：

本题与  例4： 42. 接雨水 - 力扣（LeetCode）思路类似，接雨水的关键在于寻找波谷，而本题的关键在于寻找波峰。

本题要记录每个柱子 左边第一个小于该柱子的下标，而不是左边第一个小于该柱子的高度。

所以需要循环查找，也就是下面在寻找的过程中使用了while。 

 如上图所示：minLeftIndex[i] = 1，minRightIndex[i] = 4，

minRightIndex[i]  -  minLeftIndex[i] - 1 = 4 - 1 - 1 = 2 即为波峰的宽度；

height[i] = 5 即为波峰的高度；

二者相乘即为柱状图中最大的矩形。

解法二：单调栈 

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int result = 0;
        stack<int> st;
        heights.insert(heights.begin(), 0);// 数组头部加入元素0
        heights.push_back(0);// 数组尾部加入元素0
        st.push(0);
        // 第一个元素已经入栈，从下标1开始
        for (int i = 1; i < heights.size(); i++) {
            if (heights[i] > heights[st.top()]) {// 情况一
                st.push(i);
            } else if (heights[i] == heights[st.top()]) {// 情况二
                st.pop();// 这个可以加，可以不加，效果一样，思路不同
                st.push(i);
            } else {// 情况三
                while (!st.empty() && heights[i] < heights[st.top()]) { // 注意是while
                    int mid = st.top();
                    st.pop();
                    if (!st.empty()) {
                        int left = st.top();
                        int right = i;
                        int w = right - left - 1;
                        int h = heights[mid];
                        result = max(result, h * w);
                    }
                }
                st.push(i);
            }
        }
        return result;
    }
};
//单调栈
//时间复杂度O(n)
//空间复杂度O(n)

 分析：

本题若采用单调栈的方法解题，则与 例4： 42. 接雨水 - 力扣（LeetCode）的不同之处在于单调栈内的顺序。

在 例4： 42. 接雨水 - 力扣（LeetCode） 中找每个柱子左右两边第一个大于该柱子高度的柱子，所以单调栈从栈头（元素从栈头弹出）到栈底的顺序应该是从小到大的顺序。

因为本题是要找每个柱子左右两边第一个小于该柱子的柱子，所以从栈头（元素从栈头弹出）到栈底的顺序应该是从大到小的顺序！

其实就是栈顶和栈顶的下一个元素以及要入栈的三个元素组成了我们要求最大面积的高度和宽度 ！

三种逻辑情况：

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

另一个需要注意的点是，height数组的首尾各加了一个0！ 

末尾为什么要加元素0？

如果数组本身就是升序的，例如[2,4,6,8]，那么入栈之后 都是单调递减，一直都没有走 情况三 计算结果的哪一步，所以最后输出的就是0了。 如图：

 所以，结尾加一个0，就会让栈里的所有元素，走到情况三的逻辑。

 开头为什么要加元素0？

如果数组本身是降序的，例如 [8,6,4,2]，在 8 入栈后，6 开始与8 进行比较，此时我们得到 mid（8），rigt（6），但是得不到 left。

（mid、left，right 都是对应版本一里的逻辑）

因为 将 8 弹出之后，栈里没有元素了，那么为了避免空栈取值，直接跳过了计算结果的逻辑。

之后又将6 加入栈（此时8已经弹出了），然后 就是 4 与 栈口元素 8 进行比较，周而复始，那么计算的最后结果resutl就是0。 如图所示：

 代码精简版：

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int result = 0;
        stack<int> st;
        st.push(0);
        heights.insert(heights.begin(), 0);
        heights.push_back(0);
        for (int i = 1; i < heights.size(); i++) {
            while (!st.empty() && heights[i] < heights[st.top()]) {
                int mid = st.top();
                st.pop();
                if (!st.empty()) {
                    int left = st.top();
                    int right = i;
                    int w = right - left - 1;
                    int h = heights[mid];
                    result = max(result, h * w);
                }
            }
            st.push(i);
        }
        return result;
    }
};