代码随想录算法训练营第43天 | 第十章 单调栈part01

---

单调栈

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

单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。
更直白来说，就是用一个栈来记录我们遍历过的元素

问题

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

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

2. 单调栈里元素是递增呢？ 还是递减呢？（从栈头到栈底）
   如果求一个元素右边第一个更大元素，单调栈就是递增的，如果求一个元素右边第一个更小元素，单调栈就是递减的。

关键

过程绘图表示

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

---

739. 每日温度

Leetcode链接

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        stack<int> st;
        vector<int> result(temperatures.size(), 0);
        st.push(0); // 放入下标为0的元素
        for (int i = 0; i < temperatures.size(); i++) {
            if (temperatures[i] <
                temperatures
                    [st.top()]) { // 此时元素小于栈顶的元素，保持了了递增，直接放入
                st.push(i);
            } else if (temperatures[i] == temperatures[st.top()]) { // 相等，依旧放入
                st.push(i);
            } else { // 此时元素大于栈顶的元素，将栈顶元素弹出，同时记录二者的距离即i-st.top()
                while (!st.empty() && temperatures[i] > temperatures[st.top()]) {
                    result[st.top()] = i - st.top();
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};

496.下一个更大元素 I

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        // 先用umap放入nums1的元素，再遍历nums2的元素，找是否nums2[j]在umap里出现过
        unordered_map<int, int> umap;
        for (int i = 0; i < nums1.size(); i++) {
            umap[nums1[i]] = i; // value放入下标，key放对应的元素值
        }
        stack<int> st;
        vector<int> result(nums1.size(), -1);
        if (nums1.size() == 0)
            return 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 {
                while (!st.empty() && nums2[i] > nums2[st.top()]) {
                    if (umap.count(nums2[st.top()]) >  0) { // 查看此时的元素是否在nums1里出现过
                        int index = umap[nums2[st.top()]];
                        result[index] = nums2[i];
                    }
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};

503.下一个更大元素II

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

---

总结