单调栈-＞算法实现

引言（单调栈理论知识）

理论分析

对于一维数组，要寻找一个元素的右边或者左边第一个比自己大或者第一个比自己小的元素的位置，通常使用单调栈
单调栈的时间复杂度是 o(n)，空间复杂度也是 o(n)
单调栈的本质是空间换时间，通过一个栈来记录遍历过的元素，每次和栈顶进行对比从而找到下一个较大值或较小值
一般单调栈里面存放的是元素的索引，可通过数组和索引找出索引对于的元素
如果是找下一个较大值，那么从 栈底 到 栈顶 是 从大到小排序的，也就是递减的
如果是找下一个较小值，那么从 栈底 到 栈顶 是 从小到大排序的，也就是递增的
举例：对于数组 T = [73, 74, 75, 71, 71, 72, 76, 73]，找它每个元素的下一个较大元素在此元素后面的第几个
输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]
使用单调栈主要有三个判断条件：
当前遍历的元素T[i]小于栈顶元素 T[st.top()] 的情况
当前遍历的元素T[i]等于栈顶元素 T[st.top()] 的情况
当前遍历的元素T[i]大于栈顶元素 T[st.top()] 的情况
以下使用单调栈解决此问题：
①首先将第一个元素的加入单调栈

②判断T[1] 与 T[st.top()] 即 T[0] 的大小，由于T[1] > T[0]，而找下一个较大元素要求单调栈递减，因此T[0] 出栈， T[1] 入栈，res数组可以进行记录了，res[0] = 1，即 T[0] 的下一个比他大的元素是 T[1]

③判断 T[2] 与 T[1]，T[2] > T[1]，因此同理，T[1] 出栈， T[2] 入栈，res[1] = 1，即 T[1] 的下一个较大元素在它后面的第一个

④判断 T[3] < T[2]，由于单调栈递减，因此可以直接入栈
⑤判断 T[4] == T[3]，由于是找下一个较大元素，而不是大于等于，因此单调栈中可以存放相等的元素，所以直接入栈

⑥判断 T[5] > T[4]，因此 T[4] 出栈，res[4] = 5 - 4 = 1；
继续判断 T[5] > T[3]，因此 T[3] 出栈，res[3] = 5 - 3 = 2
但是 T[5] < T[2]，因此此时 T[5] 入栈


⑦判断 T[6] > T[5]，因此 T[5] 出栈，res[5] = 6 - 5 = 1；
继续判断 T[6] > T[2]，因此 T[2] 出栈，res[2] = 6 - 2 = 4；
此时栈空，则 T[6] 入栈

⑧判断 T[7] < T[6]，因此直接入栈
此时遍历完成，栈中只剩 T[6] 和 T[7]，说明右边没有比他俩还大的元素了，因此 res[6] 和 res[7] 需要为0，那么直接在申请 res 数组的时候初始化为0，就不用再管了

代码模板

按照上述分析，可写出代码：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& T) {
        // 递增栈
        stack<int> st;
        vector<int> result(T.size(), 0);
        st.push(0);
        for (int i = 1; i < T.size(); i++) {
            if (T[i] < T[st.top()]) {                       // 情况一
                st.push(i);
            } else if (T[i] == T[st.top()]) {               // 情况二
                st.push(i);
            } else {
                while (!st.empty() && T[i] > T[st.top()]) { // 情况三
                    result[st.top()] = i - st.top();
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};

可对情况1，2，3进行简化：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& T) {
        stack<int> st; // 递增栈
        vector<int> result(T.size(), 0);
        for (int i = 0; i < T.size(); i++) {
            while (!st.empty() && T[i] > T[st.top()]) { // 注意栈不能为空
                result[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);

        }
        return result;
    }
};

后续采用的就是简化版本的代码进行解题

每日温度

题目

leetcode739

题解

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

接雨水

题目

leetcode42

分析

其实就是找 任一元素 右边 和 左边 第一个比自己大的元素，这样可以形成“凹”，从而计算雨水面积，因此使用单调栈，并且从 栈底 到 栈顶 是递减的
这样的话一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子
如图

因此通过 此时遍历出大的元素、栈顶元素、栈顶的下一个元素 可计算出雨水的宽和高，从而计算面积

题解

class Solution {
public:
    int trap(vector<int>& height) {
        //单调栈
        stack<int> st;
        st.push(0);
        int res = 0;
        for (int i = 1; i < height.size(); i++) {
            while (!st.empty() && height[i] > height[st.top()]) {
                int mid = height[st.top()];
                st.pop();
                if (!st.empty()) res += (min(height[st.top()], height[i]) - mid) * (i - st.top() - 1);
            }
            st.push(i);
        }

        return res;
    }
};

柱状图中最大的矩形

题目

leetcode84

分析

接雨水是求下一个较大值和前一个较大值；最大矩形是求下一个较小值和前一个较小值
因此此问题使用 单调栈，找到heights[i]左边第一个和右边第一个比他小的
接雨水是找凹的，因此存放是由栈底到栈顶是从大到小，这样遇见大的就产生凹；
最大矩形是凸的，因此存放是由栈顶到栈底是从小到大，这样遇见小的就产生凸

题解

class Solution {
public:
//接雨水是求下一个较大值和前一个较大值；最大矩形是求下一个较小值和前一个较小值
    int largestRectangleArea(vector<int>& heights) {
        //单调栈，找到heights[i]左边第一个和右边第一个比他小的
        //接雨水是找凹的，因此存放是由栈底到栈顶是从大到小，这样遇见大的就产生凹；
        //最大矩形是凸的，因此存放是由栈顶到栈底是从小到大，这样遇见小的就产生凸
        heights.insert(heights.begin(), 0);//头部加0，保证栈底永远都有一个元素，这样st.pop()之后mid * (i - 1 - st.top())中st.top()存在
        heights.push_back(0);//尾部加0,防止这种[1,2,3]递增的一直不走while循环
        stack<int> st;
        st.push(0);
        int res = 0;
        for (int i = 1; i < heights.size(); i++) {
            while (!st.empty() && heights[i] < heights[st.top()]) {
                int mid = heights[st.top()];
                st.pop();
                res = max(res, mid * (i - 1 - st.top()));
            }
            st.push(i);
        }

        return res;
    }
};

对于 头部加0 和 尾部加0 这个操作，可以自己动手模拟一个第一个示例就知道为什么要加0了