代码随想录算法训练营第四十八天|单调栈、每日温度、下一个更大的元素

单调栈

什么是单调栈：保持栈中元素为单调递增或者单调递减。

如果为单调递增就是求当前元素前面或者后面比它大的元素位置。如果为单调递减就是求当前元素前面或者后面比它小的元素位置。

单调栈的作用：存放遍历过的元素

每日温度 leetcode 739

思路：将当前元素与栈顶元素相比，如果当前元素大于栈顶元素，则对结果赋值然后将栈顶元素弹出直到当前元素小于等于栈顶元素则把当前元素压入栈内作为新的栈顶，如果当前元素小于等于栈顶元素则将当前元素的下标压入栈内。注意是将下标存入栈中。

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

精简版本：

只要栈不为空且当前元素大于栈顶元素进行操作，将上面版本的当前元素小于等于栈顶元素后的入栈以及当前元素大于栈顶元素更新结果及弹栈之后的入栈合并。

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

下一个更大元素Ⅰ leetcode 496

解法一：暴力解法

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

解法二：单调栈

思路：先对数组1和数组2中相同元素建立一个哈希映射。遍历数组2使用单调栈思想找到下一个更大元素再根据哈希映射收货结果。

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int,int> map;
        vector<int> res(nums1.size(),-1);
        for(int i=0;i<nums1.size();i++){
            map[nums1[i]]=i;
        }
        stack<int> st;
        st.push(0);
        for(int i=0;i<nums2.size();i++){
            while(!st.empty()&&nums2[i]>nums2[st.top()]){
                auto it=map.find(nums2[st.top()]);
                if(it!=map.end()) res[it->second]=nums2[i];
                st.pop();
            }
            st.push(i);
        }
        return res;
    }
};

下一个更大的元素Ⅱ leetcode 503

解法一：将数组扩充两倍，转换为最基础的单调栈问题。

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

解法二：遍历过程中模拟扩充数组

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