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

文档链接：https://programmercarl.com/

LeetCode739.每日温度

题目链接：https://leetcode.cn/problems/daily-temperatures/

思路：第一次接触单调栈，通常是一维数组，要寻找任一个元素的右边或者左边第一个比自己大或者小的元素的位置，此时我们就要想到可以用单调栈了。时间复杂度为O(n)。

单调栈：

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        vector<int> result(temperatures.size(), 0);
        stack<int> st;
        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;
    }
};

---

LeetCode496.下一个更大元素Ⅰ

题目链接：https://leetcode.cn/problems/next-greater-element-i/

思路：这题本质上跟上一题一样。相较于上题记录下标，因为没有重复元素，这题直接记录值会方便点。

求哪个数组中的前一个或后一个更大元素，哪个数组元素入栈。这道题还需要建立nums1中数组元素值和下标的映射关系。

注意题目中说是两个没有重复元素 的数组 nums1 和 nums2。

没有重复元素，我们就可以用map来做映射了。根据数值快速找到下标，还可以判断nums2[i]是否在nums1中出现过。

暴力：

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(nums2[j] == nums1[i]) {
                    for(int k = j + 1; k < nums2.size(); k++) {
                        if(nums2[k] > nums2[j]) {
                            result[i] = nums2[k];
                            break;
                        }
                    }
                }
            }
        }
        return result;
    }
};

单调栈：

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

总结：递减栈就是求右边第一个比自己小的元素了。