【单调栈】每日温度、下一个更大的元素 I、下一个更大的元素 II

每日温度

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

只有把栈中比当前元素小的元素全部出栈，才能把当前元素入栈，栈中元素一定是降序的（栈底->栈顶）

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        int n = temperatures.size();
        vector<int> ans(n, 0);
        stack<int> st;

        for(int i = 0; i < n; i++){
            while(!st.empty() && temperatures[i] > temperatures[st.top()]){
                // 栈不空，下一个温度更高，则出栈，更新ans
                ans[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);
        }
        return ans;
    }
};

下一个更大的元素 I

用单调栈处理nums2，将有下一个更大元素的值，和其对应的下一个更大元素用哈希表记录下来，遍历nums1，即可得到答案

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        int n = nums2.size();
        stack<int> st;
        vector<int> nextGreater(n, -1);
        for (int i = 0; i < n; i++) {
            while (!st.empty() && nums2[i] > nums2[st.top()]) {
                nextGreater[st.top()] = nums2[i];
                st.pop();
            }
            st.push(i);
        }
        // val, nextGreater
        unordered_map<int, int> mp;
        for (int i = 0; i < n; i++) {
            mp[nums2[i]] = nextGreater[i];
        }
        vector<int> ans;
        for (int num : nums1) {
            ans.push_back(mp[num]);
        }
        return ans;
    }
};

下一个更大的元素 II

将数组拷贝一份到末尾，长度变为2*n，遍历整个数组

当前元素nums[i] > 栈顶元素 nums[st.top()]时，需要不断用当前元素nums[i]填写栈顶元素对应的位置ans[st.top()]，填写完成后st.pop()，直到栈顶元素对应的值不小于nums[i]，然后把nums[i]对应的下标i压栈

当前元素nums[i] <= 栈顶元素nums[st.top()]，直接将当前元素对应的下标i压栈

单调栈中自底向上存放的下标对应的元素是递减的

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n, -1);
        for (int i = 0; i < n; i++) nums.push_back(nums[i]);
        stack<int> st;
        
        for (int i = 0; i < 2 * n; i++) {
            // nums[i] > nums[st.top()]时，不断用nums[i]填写ans[st.top()]，st.pop()
            while (!st.empty() && nums[i] > nums[st.top()]) {
                if(st.top() < n) ans[st.top()] = nums[i];
                st.pop();
            }
            // 当前元素nums[i] <= 栈顶元素 或 清除完栈中小于nums[i]的元素后，将i压栈
            st.push(i);
        }
        return ans;
    }
};

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