代码随想录算法训练营第五十八天|739. 每日温度、496.下一个更大元素 I

739. 每日温度

通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。
单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是只需要遍历一次。

在使用单调栈的时候首先要明确如下几点：

单调栈里存放的元素是什么？
单调栈里只需要存放元素的下标i就可以了，如果需要使用对应的元素，直接T[i]就可以获取。

单调栈里元素是递增呢？ 还是递减呢？
注意一下顺序为 从栈头到栈底的顺序，
这里我们要使用递增循序，因为只有递增的时候，加入一个元素i，才知道栈顶元素在数组中右面第一个比栈顶元素大的元素是i。

使用单调栈主要有三个判断条件。

当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况

前两种情况，直接入栈，最后一种情况就是当前遍历元素就是栈顶元素T[st.top()]右侧第一个比他大的数。

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

上面代码将三种情况分开来写，条理清晰，下面为简化版本

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

496.下一个更大元素 I

与上题类似，只不过是两个数组，看似复杂

可以将nums1以map记录，只需遍历nums2查找其中元素是否在nums1中出现过，如果出现了再进行结果记录，而且这里结果数组记录的是元素，而不是位置

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result(nums1.size(), -1);
        stack<int> st;
        unordered_map<int,int> umap;
        for (int i = 0; i < nums1.size(); i++) {
            umap[nums1[i]] = i;
        }
        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 {
                while (!st.empty() && nums2[i] > nums2[st.top()]) {
                    if (umap.find(nums2[st.top()]) != umap.end()) { //在nums1中存在再进行操作
                        int index = umap[nums2[st.top()]];
                        result[index] = nums2[i];
                    }
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};