单调栈和单调队列

文章目录

• 前言
• 一、单调栈
  • 下一个更大的元素1
  • 下一个更大的元素2
  • 下一个更大的元素3
• 二、单调队列

---

前言

介绍 单调栈和单调队列的知识 

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、单调栈

单调栈解决的问题是： 

可以找到从左/右遍历第一个比它大/小的数的位置

下一个更大的元素1

​​​​​​下一个更大元素 I

给你两个 没有重复元素 的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。

请你找出 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出 -1 。

示例 1:

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
    对于 num1 中的数字 4 ，你无法在第二个数组中找到下一个更大的数字，因此输出 -1 。
    对于 num1 中的数字 1 ，第二个数组中数字1右边的下一个较大数字是 3 。
    对于 num1 中的数字 2 ，第二个数组中没有下一个更大的数字，因此输出 -1 。

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        map<int,int> ans;
        stack<int> s;
        //维护一个递减序列
        for(int i=0;i<nums2.size();i++){

            while(!s.empty()){
                if(s.top()<nums2[i]){
                    ans[s.top()]=nums2[i];
                    s.pop();
                }
                else{
                    break;
                }
            }
            s.push(nums2[i]);
        }
        vector<int>res;
        for(int i=0;i<nums1.size();i++){
            if(ans[nums1[i]]){
                res.push_back(ans[nums1[i]]);
            }else{
                res.push_back(-1);
            }
        }
        return res;
    }
};

503. 下一个更大元素 II

下一个更大的元素2

给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。

示例 1:

输入: [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

题解：  由于是可以循环的搜索，可以将数组扩大2倍，仍然按照单调栈的思想做

class Solution {
public:
    struct node{
        int id;
        int val;
    };
    vector<int> nextGreaterElements(vector<int>& nums) {
        map<int,int> ans;
        vector<int>nums2;
        for(int i=0;i<nums.size();i++){
            nums2.push_back(nums[i]);
        }
// 将nums2扩大两倍
        for(int i=0;i<nums.size();i++){
            nums2.push_back(nums[i]);
        }
        stack<node> s;
        //维护一个递减序列
        for(int i=0;i<nums2.size();i++){

            while(!s.empty()){
                if(s.top().val<nums2[i]){
                    ans[s.top().id]=i+1;
                    s.pop();
                }
                else{
                    break;
                }
            }
            node node;
            node.id = i;
            node.val = nums2[i];
            s.push(node);
        }
        vector<int>res;
        for(int i=0;i<nums.size();i++){
            if(ans[i]){
                res.push_back(nums2[ans[i]-1]);
            }else{
                res.push_back(-1);
            }
        }
        return res;
    }
};

556. 下一个更大元素 III

下一个更大元素3

思路：找到第一个不满足递增序列的下标a以及它右边恰好大于它的数的下标b，两者进行交换，并排序[0,a)

class Solution {
public:
    struct node{
        int id;
        int val;
    };
    int nextGreaterElement(int n) {
        vector<int> res;
        int sum = n;
        while(sum){
            res.push_back(sum%10);
            sum = sum / 10;
        }
        int swap_i = 0, swap_j = 0;
        stack<node> s;
        int tag=0;
        for(int i=0;i<res.size();i++){
            if(tag)
                break;
            if(!s.empty()){
                while(!s.empty()){
                    if(s.top().val>res[i]){
                        swap_i = s.top().id;
                        swap_j = i;
                        tag = 1;
                        s.pop();
                    }else{
                        break;
                    }
                }
            }
            node nodes;
            nodes.id = i;
            nodes.val = res[i];
            s.push(nodes);
        }
        if(swap_i == 0 && swap_j ==0 )
            return -1;
        swap(res[swap_i],res[swap_j]);
        sort(res.begin(),res.begin()+swap_j,greater<int>());
        long long answer = 0;
        for(int i=res.size()-1;i>=0;i--){
            answer += res[i];
            answer *=10;
        }
        answer /=10;
        if(answer > pow(2,31)-1){
            return -1;
        }
        return answer;
    }
};

二、单调队列

单调队列解决的问题为：

单调队列是一种主要用于解决滑动窗口类问题的数据结构，即，在长度为 n 的序列中，求每个长度为 m 的区间的区间最值。它的时间复杂度是 o(n) 

求上图的长度为4的滑动窗口的最大值 ，需要维护一个单调递减的双端队列

如上图的长度为4的滑动窗口的最小值，需要维护一个单调递减的双端队列

---