单调栈介绍和简单应用

求左边元素（逆序遍历）
其实通过逆序的遍历，就将求左边的元素 转化成 求右边的元素 这样求左侧第一个大就变成了求右侧第一个大
左侧第一个更大 单调递增
左侧第一个更小 单调递减

使用单调栈主要有三个判断条件。
当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况
很多简洁的代码将小于和等于的情况合并了。

// 版本一
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;
    }
};

// 版本二
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;
    }
};

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int>result(nums.size(),-1);
        //存的是下标
        stack <int>st;

        for (int i=0;i<nums.size()*2;i++)
        {
            int ii=i%nums.size();
                while(!st.empty()&&nums[ii]>nums[st.top()])
                {
                    result[st.top()]=nums[ii];
                    st.pop();
                }
                st.push(ii);
            
        }
        return result;
    }
};

其实这道题还有一个小细节，就是reasult会不会被覆盖的问题。(这个问题指的是当我的ii重复的时候，原先result中正确的数据会不会被脏数据覆盖掉)
举个例子，假如这个数组是1 2 3 4 3 ,那么通过这个取模的操作，我们实际遍历的数是这样的 1 2 3 4 3 我是可爱的分界线 1 2 3 4 3.
当i还小于nums.size（）的时候（为了方便叙述 称为 第一轮）
result数组里面为 2 3 4 -1 -1
第二轮之后为
2 3 4 -1 4
显然的原先正确数据不会被更改，因为你后面遍历的数和前面的是一样的，那么即使ii因为取模而重复了，但是他所获得的结果和前面是一样的。
举个例子 当你遍历到第一个1的时候答案是2，当你遍历到第二个1时结果还是后面的2.也就是说在第一轮有答案的元素，到第二轮时答案不会变。当然第一轮结束 4 3还在栈里面。

上图中我给了一组数据，序号代表了你遍历这个数组的时候这个凹槽是第几个凹槽。
当你找完了一个凹槽，将这个凹槽 中 (图中 左中右的中）的元素pop，不知道怎么描述。想说的话都在图里了。我们这里是一层一层的计算的。
以上证明了可行性。
代码

class Solution {
public:
    int trap(vector<int>& height) {
        stack<int>st;
        
        long long ans=0;
        for (int i=0;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;
                ans+=h*w;
                }
            }

             st.push(i);
        }
        return ans;
    }
};

参考了B站上代码随想录的视频