初始单调栈

单调栈:

指栈中元素的值都是单调递增或者递减的，递增的可以求在数组中第一个比自己大的元素，递减可以用来求第一个比自己小的元素。

739. 每日温度 - 力扣（LeetCode）

今天刷的题目有点多，一时间看题目有点分不清楚了。

思路：这种题一眼就能想到暴力解法，比如用两层for循环，只要找到一个值大于当前值，就将该值赋给当前的数组。当然是肯定会超时的。

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int>answer(temperatures.size(), 0);
        //暴力解法是肯定会超出时间的
        for (int i = 0; i < temperatures.size();i++)
        {
            for (int j = i + 1; j < temperatures.size(); j++)
            {
                if (temperatures[j] > temperatures[i])//只要找到有比当前大的，就可以让j-i赋值给我
                {
                    answer[i] = j - i;
                    break;
                }
            }
        }
        return answer;
    }
};

单调栈解法思路：

定义一个栈，并初始化单调栈，将第一个元素下标插入栈中，只要方便在后面用来取单调栈的元素。

1、定义单调栈，明确单调栈的下际的含义

2、初始化当前栈

3、确定遍历顺序

4、明确出栈和入栈

因为是要寻找每一个元素比当前元素大的下标，也就是在第几天后会出现。

有两种情况，如果当前温度高于我需要遍历的，那么就是返回当前值的结果减去需要寻找的下标的值。

answer[st.top()] = i - st.top();

找到当前的值之后，要将该值弹出，这样才能够让后面的值继续判断，并且当前循环结束，要将nums[i]加入其中，因为栈中已经都是比我当前的值大，也就是在我之后。

如果未能找到初始值，那么也不用管当前的。因为一开始就初始化了。

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

496. 下一个更大元素 I - 力扣（LeetCode）

思路：本题可能一开始会将其复杂化，因为要寻找nums1中元素在nums2中出现的下标，vector数组中也没用直接能够返回当前的函数，得用迭代器，然后再用当前迭代器减去开始的值。

寻找某个元素在在数组中是否出现过，是不是可以想到哈希表。

在这可以以nums1中元素作为关键词，元素下标作为值，来建立一个unordered_map哈希表。

这样在对nums2中进行寻找时，只要找到当前第一个值比当前值大，那么就对该值在nums1中进行寻找，若不能找到，则将此元素弹出，若可以，那么就让结果数值中的nums1元素的下标等于当前nums2的元素。

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int>st;
        vector<int>result(nums1.size(), -1);
        if (nums1.size() == 0)return result;

        unordered_map<int, int>umap;
        for (int i = 0; i < nums1.size(); i++)
        {
            umap[nums1[i]] = i;//采用数值为关键词，来查找，并用i作为result的下标；
        }
        st.push(0);
        for (int i = 1; i < nums2.size(); i++) {
                if (nums2[i] < nums2[st.top()]) {
                    st.push(i);
                }
                else if (nums2[i] == nums2[st.top()]) {
                    st.push(i);
                }
                else {
                    //妙就妙在这，如果存在有比当前大的，那么就要判断当前栈顶的元素，是否在nums1中出现过，若出现过，则可以进行操作，若没有，直接弹出
                    while (!st.empty() && nums2[i] > nums2[st.top()]) {
                        if (umap.count(nums2[st.top()]) > 0) { // 看map里是否存在这个元素
                            int index = umap[nums2[st.top()]]; // 根据map找到nums2[st.top()] 在 nums1中的下标
                            result[index] = nums2[i];//让当前result下标为index的值等于nums[i];
                        }
                        st.pop();
                    }
                    st.push(i);
                } 
        }
        return result;
    }
};