代码随想录算法训练营第48天| 单调栈 739. 每日温度 、 496.下一个更大元素 I 、503.下一个更大元素II

单调栈理论基础：

为了找数组中某个元素后面第一个比他大或者比他小的元素，就会用到单调栈。此时从栈头到栈尾的元素大小是单调递增的或单调递减的，这就是单调栈。如果要找到一个元素右边第一个比他大的元素，则首先把这个元素入栈，然后遍历下一个元素，使他与栈头元素比较。如果这个元素小于栈头元素，则入栈；如果大于，则栈头元素出栈，一直出栈到栈头元素比他大为止，然后该元素入栈。寻找右边第一个比他小的元素同理。

739. 每日温度

题目链接：739. 每日温度

思路：单调栈 从栈头到栈尾 元素大小递增。原因：如果当前访问下边对应元素大于栈顶元素 则result数组存入栈顶下标对应的距离 如果小于或者等于 则入栈 成为新的栈顶元素 所以栈头到栈尾逐渐递增。
初始化：留在栈中的元素说明右边没有比他大的元素 所以为0 初始化为0 不操作

代码：

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

496.下一个更大元素 I

题目链接：496. 下一个更大元素 I

思路：因为要求一个数组中所对应的和另一个数组相同的值的该数组的右边第一个比他大的元素，所以我们要让这两个数组的下标产生联系，即映射。这样可以避免两层for循环带来的时间复杂度，在这里我们使用了哈希映射，即哈希表。使用哈希映射 hashmap[nums1[i]] = i，利用值来对应下标。

代码：

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        //处理完nums2之后再赋给nums1
        //如果当前元素比栈头元素大 则存储当前元素的值 否则入栈
        vector<int> res(nums1.size(),-1);
        stack<int> stk;
        unordered_map<int,int> hashmap;
        stk.push(0);
        for(int i=0;i<nums1.size();i++) hashmap[nums1[i]]=i;

        for(int i=1;i<nums2.size();i++){
            while(!stk.empty()&&nums2[i]>nums2[stk.top()]){
                //如果可以在哈希表中找到nums2对应的i
                if(hashmap.find(nums2[stk.top()])!=hashmap.end()){
                    res[hashmap[nums2[stk.top()]]]=nums2[i];
                }
                //res[stk.top()]=nums2[i];
                stk.pop();
            }
            stk.push(i);
        }
        return res;
    }
};

503.下一个更大元素II

题目链接：503. 下一个更大元素 II

思路：所谓循环数组，实际上我们把这个数组延长一倍放在尾部后面就可以实现相同的效果。另一个方法就是取余，使下标可以遍历到二倍的数组大小，但是对下标进行数组大小的取余，这样也可以实现转圈的效果。相比第一种方法，不需要申请额外空间，可以空间复杂度。其余的和上一题相同，直接单调栈就可以。

代码：

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        //如果当前值比栈头元素大 则存储 否则 入栈
        vector<int> res(nums.size(),-1);
        stack<int> stk;
        stk.push(0);
        for(int i=0;i<2*nums.size();i++){
            while(!stk.empty()&&nums[i%nums.size()]>nums[stk.top()]){
                res[stk.top()]=nums[i%nums.size()];
                stk.pop();
            }
            stk.push(i%nums.size());
        }
        return res;
    }
};