【Day62】代码随想录值单调栈part1——每日温度、下一个更大元素I

继续补代码随想录中落下的部分，下午的时候已经把动态规划的问题全部刷完了，今天开始单调栈章节，开冲！！！

今日任务：

• 739.每日温度
• 496.下一个更大元素I

题目一：739.每日温度

Leetcode题目：【739.每日温度】

单调栈适合解决什么类型的题目：
单调栈的任务能帮你找到（左边或者右边）第一个比他（大/小）的元素。
这个题目是单调栈最基础的题目。

1.1 什么是单调栈

单调栈本质就是一个栈，但是需要保证栈中的元素是递增或者递减；
单调栈中放下标，通过下标做差值来计算距离；
递增：当前左边或者右边第一个比他大的元素；递减：当前左右或右边第一个比他小的元素。
单调栈的作用：是为了存放遍历过的元素，然后和当前遍历的元素做对比

1.2 模拟单调栈的过程

下面的代码有两点需要注意的地方：
（1）第一个st.push()是需要的，就是当入口元素把栈中的元素都清空之后，需要把自己加进去；
（2）在while中，还是需要判断比较的，只有大于了才能被清掉。

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

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

Leetcode题目：【496.下一个更大元素I】

自己的思路：原暴力方法解决或者在上面的题目上面套了一个壳子，然后对应位置去找即可。

方法一：暴力解决思路（也可以通过唉）：

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result(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; k<nums2.size(); k++){
                        if(nums2[k] > nums2[j]){
                            result[i] = nums2[k];
                            break;
                        }
                    }
                }
            }
        }
        return result;
    }
};

方法二：单调栈方法解决：

这个有点意思的就是需要用哈希做一个映射key-value，其他的基本就是照搬单调栈。
这个哈希太巧妙了，这样的话就不需要重开一个比较大的数组了。
unordered_map<int, int> map;
for(int i = 0; i<nums1.size(); i++) map[nums[i]] = i;

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result(nums1.size(), -1);
        stack<int> st;
        st.push(0);
        int index = 0;
        unordered_map<int, int> map;
        for(int i = 0; i<nums1.size(); i++) map[nums1[i]] = i;
        // 下面就是单调栈的操作了
        for(int i = 1; i<nums2.size(); i++){
            if(nums2[i] <= nums2[st.top()]) st.push(i);
            else{
                while(!st.empty() && nums2[i] > nums2[st.top()]){
                    // 如果在nums2中能找到nums1中的元素
                    if(map.count(nums2[st.top()]) > 0){
                        index = map[nums2[st.top()]];
                        result[index] = nums2[i];
                    }
                   st.pop();
                }
                st.push(i);
            }
        }

        return result;
    }
};