10.栈与队列Ⅲ

最新推荐文章于 2025-05-11 16:59:11 发布

原创最新推荐文章于 2025-05-11 16:59:11 发布 · 1.9k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #leetcode

leetcode刷题专栏收录该内容

19 篇文章

订阅专栏

本文详细介绍了如何使用单调队列解决滑动窗口最大值问题，以及如何利用优先队列找到数组中出现频率前K的元素。通过具体的解题思路和代码实现，展示了单调队列和优先队列在数据结构与算法中的应用。

10.栈与队列Ⅲ

239.滑动窗口最大值

题目描述

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

解题思路

本题本质需要构建一个单调的队列，每次将滑窗的元素放在队列里，队列里的元素是要排序的，而且要最大值放在出队口，这样每次返回队头元素即为滑窗的最大值。

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。

设计单调队列的时候，pop，和push操作要保持如下规则：

pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

保持如上规则，每次窗口移动的时候，只要访问que.front()就可以返回当前窗口的最大值。

代码实现

class Solution {
public:
//构建一个单调队列类
class MyQueue
{public:
    deque<int>que;
    //对单调队列，需要重写pop函数，来保证队头始终为最大值
    void pop(int value){
        if(!que.empty()&&value==que.front())
        {
            que.pop_front();//队头是最大值，如果要弹的元素等于最大就弹出，说明当前最大值被消掉了。如果不等就不用执行操作。
        }
    }
    //对单调队列，需要重写push函数，因为放元素进来可能破坏单调性，需要保证队列为递减的。
    void push(int value)
    {
        while(!que.empty()&&value>que.back())
        {
            que.pop_back();
        }
        que.push_back(value);
    }
    //查询队列最大元素
    int front()
    {
        return que.front();
    }
};
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        //定义一个单调队列
        MyQueue que;
        vector<int> res;
        for(int i=0;i<k;i++){
            que.push(nums[i]);//放入前k个元素
        }
        res.push_back(que.front());
        //移动滑窗，再放入元素
        for(int i=k;i<nums.size();i++)
        {
            que.pop(nums[i-k]);//滑窗移动弹出队头元素
            que.push(nums[i]);//加入队尾元素
            res.push_back(que.front());//将当前滑窗内最大值返回
        }
        return res;
    }
};

总结

本题第一反应用双指针做，写出了如下的代码，代码漏考虑了一旦滑窗移动，之前的max值可能出滑窗，因此某些测试案例无法通过。

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int>res;//存储结果
        int right,len,max;
        len=nums.size()-1;
        max=0;
        for(int i=0;i<k;i++){
            max=max>nums[i]?max:nums[i];
        }
        res.push_back(max);
        //窗口往后滑的时候，之前的最大值可能会出队
        for(right=k;right<=len;right++)
        {
            max=max>nums[right]?max:nums[right];
            res.push_back(max);
        }
        return res;
    }

若想判断上次滑窗的max值在滑窗移动后是否还在滑窗内，最好的办法还是在单个滑窗内给数字排序。因而构造一个单调队列的方法就可以实现每次滑窗内的数据是排过序的，并且只保留递减的数据，这样就可以确保最大值始终在队头，返回队头元素就是滑窗最大值。

要实现单调队，需要自己创建一个类，定义一种单调递减的数据结构。那么就需要自己重写deque的pop出队函数，和push入队函数。

347.前 K 个高频元素

题目描述

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

解题思路

1.统计数组元素出现频率，考虑用哈希表。key存储元素，value存储出现次数。
2.由于要返回频率前k高的，因此需要按value排序。而map是按照key值的大小按序存储的。因此无法利用map自带的排序

3.由于需要按value排序，因此需要重新构造一种数据结构：优先队列。该队列是按照map的第二位value大小来排序。为了实现这种排序，需要自己定义比较的仿函数mycomparison，按照map的第二位排序。

priority_queue 模板有 3 个参数，其中两个有默认的参数；第一个参数是存储对象的类型，第二个参数是存储元素的底层容器，第三个参数是函数对象，它定义了一个用来决定元素顺序的断言。

代码实现

class Solution {
public:
//定义小顶堆数据结构
    class mycomparison
    {public:
    //通过重载（），定义一个比较的仿函数
    bool operator()(const pair<int,int>&lhs,const pair<int,int>&rhs)
    {
        return lhs.second>rhs.second;//左节点的第二位大于右节点的第二位
    }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
//统计数组元素出现频率，考虑用哈希表。key存储元素，value存储出现次数。
//由于要返回频率前k高的，因此需要按value排序。
//map是按照key值的大小按序存储的。
    unordered_map<int,int>m;
    vector<int>res(k);//初始化时指定res大小
    for(int i=0;i<nums.size();i++)
    {
        m[nums[i]]++;//对应key值的value++
    }
    //对频率排序，利用大小为k的小顶堆排序，定义一个优先级队列
    priority_queue<pair<int,int>,vector<pair<int,int>>,mycomparison> pri_que;
    //扫描所有频率的数值
    for(unordered_map<int,int>::iterator it=m.begin();it!=m.end();it++)
    {
        pri_que.push(*it);//将m中的元素放入队列中
        if(pri_que.size()>k)
        {
            pri_que.pop();//
        }
    }
    //将队列中剩余元素放入res中
    for(int i=k-1;i>=0;i--)
    {
        res[i]=pri_que.top().first;//队列里的top元素为频率小的，倒序放。第一位对应的数组原始值
        pri_que.pop();//队列每读一次顶部元素，就要弹出一次，否则无法访问后续元素
    }
    return res;
    }
};

总结

栈与队列总结

C++中deque是stack和queue默认的底层实现容器（这个我们之前已经讲过啦），deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的。

我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。

deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。

SGI STL中队列底层实现缺省情况下一样使用deque实现的。

首先栈和队列是STL（C++标准库）里面的两个数据结构。

C++标准库是有多个版本的，要知道我们使用的STL是哪个版本，才能知道对应的栈和队列的实现原理。

那么来介绍一下，三个最为普遍的STL版本：

HP STL 其他版本的C++ STL，一般是以HP STL为蓝本实现出来的，HP STL是C++ STL的第一个实现版本，而且开放源代码。
P.J.Plauger STL 由P.J.Plauger参照HP STL实现出来的，被Visual C++编译器所采用，不是开源的。
SGI STL 由Silicon Graphics Computer Systems公司参照HP STL实现，被Linux的C++编译器GCC所采用，SGI STL是开源软件，源码可读性甚高。

接下来介绍的栈和队列也是SGI STL里面的数据结构，知道了使用版本，才知道对应的底层实现。

来说一说栈，栈先进后出，如图所示：

栈与队列理论2

栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。不像是set 或者map 提供迭代器iterator来遍历所有元素。

栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。

所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。

那么问题来了，STL 中栈是用什么容器实现的？

从下图中可以看出，栈的内部结构，栈的底层实现可以是vector，deque，list 都是可以的，主要就是数组和链表的底层实现。

栈与队列理论3

我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。

deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。

SGI STL中队列底层实现缺省情况下一样使用deque实现的。

我们也可以指定vector为栈的底层实现，初始化语句如下：

std::stack<int, std::vector<int> > third;  // 使用vector为底层容器的栈

刚刚讲过栈的特性，对应的队列的情况是一样的。

队列中先进先出的数据结构，同样不允许有遍历行为，不提供迭代器, SGI STL中队列一样是以deque为缺省情况下的底部结构。

也可以指定list 为起底层实现，初始化queue的语句如下：

std::queue<int, std::list<int>> third; // 定义以list为底层容器的队列

所以STL 队列也不被归类为容器，而被归类为container adapter（容器适配器）。