📍前言

本篇将学习stack&queue&priority_queue基础知识及其模拟实现。

🕺作者： 迷茫的启明星

学习路线
C语言从0到1
C++初阶
数据结构从0到1

😘欢迎关注：👍点赞🙌收藏✍️留言

🏇码字不易，你的👍点赞🙌收藏❤️关注对我真的很重要，有问题可在评论区提出，感谢阅读！！！

持续更新中~

C++ STL 之 stack&queue基础知识及其模拟实现

小星是小明的弟弟（成分复杂），对C++方面比较感兴趣，于是想向对C++比较了解的哥哥小明学习，但是又比较懒于是就…

👨‍🚀小明：”小星，今天我们来学习stack&queue基础知识及其模拟实现“

🧚小星：”啊？这么长的名字，肯定很难…（虽然对C++感兴趣，但是听起来好难，好想打游戏啊）“

👨‍🚀小明：”有句话你在高中的时候应该听老师讲过，越长越简单，说明什么都告诉你了。“

🧚小星：”也是，但是我学完了你得和我去陪我唱歌、跳舞、Rap、打篮球（好像有点道理，那就学吧，但是得耍点坏）“

👨‍🚀小明：”呃，怎么感觉有点不对呢（暗地里：呵呵），算了，答应你，在讲stack&queue之前，先由我给你简单了解一下容器适配器。”

🧚小星：“好耶（坏），但是什么是容器适配器？（疑惑）”

📍容器适配器

🎈什么是适配器？

适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。

可以这样理解：

我们生活中经常需要用到插口转换器，比如现在很多手机都只有一个插口，这个口可以直接用来充电和听音乐。但是前提是我们使用的充电器和耳机的插口要和这个设备适配的。

目前市面上很多手机的插口都是Type-C或者Lightning型号：但是，我们常用的耳机型号却是2.5mm和3.5mm的圆形接口。

所以，当我们想要把自己的3.5mm圆形接口的耳机插入Lightning或者Type-C接口的时候，就需要一个转换器。

同理，在软件系统中，常常要将一些"现存的对象"放到新的环境中，而新环境要求的接口是现对象不能满足。如以下类似的场景：

✨1、系统需要使用现有的类，而此类的接口不符合系统的需要。

✨2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。

✨3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）

👨‍🚀小明：“适配器就不展开讲了，只需要对它有个概念就好。听懂了嘛”

🧚小星：“听懂了，就是说我们上面要实现的功能是一样的，比如说给typec接口的手机充电，但是因为充电器线带错了，接口的不同需要连接一个转换器来让它变成typec的接口来给手机充电。”

👨‍🚀小明：“可以可以，有点东西，接下来简单讲一下STL标准库中stack和queue的底层结构”

🧚小星：“放马过来吧（傲娇脸）”

🎈STL标准库中stack和queue的底层结构

👨‍🚀小明：“虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，我们可以在这个网站上查到：cplusplus.com - The C++ Resources Network”

比如：

🎈deque的简单介绍(了解)

👨‍🚀小明：“再介绍一下deque”

📌deque的原理介绍

✨deque(双端队列)：是一种双开口的"连续"空间的数据结构

✨双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)

✨与vector比较，头插效率高，不需要搬移元素

✨与list比较，空间利用率比较高

✨deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：

✨双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：

🧚小星：“那deque是如何借助其迭代器维护其假想连续的结构呢？”

👨‍🚀小明：“为了实现deque的迭代器，deque采用了一个chunk大小的策略，即将容器等分成多个chunk（块），每个chunk内部是连续的一段空间，但是chunk之间并不连续。

deque的迭代器会维护一个指向当前chunk的指针，以及当前指针所在的块内的元素迭代器。

当进行迭代器的移动操作时，如果需要跨过chunk的边界，则会重新指向下一个或上一个chunk的起始位置，并更新当前指针所在的块内的元素迭代器。

这样，虽然deque内部的存储并不是连续的，但是通过迭代器的维护，可以实现高效的遍历、插入和删除操作，同时维护其假想连续的结构。如下图所示：”

🧚小星：”哦哦明白了，就是一个逻辑上的大大的数组，但是实际上是用指针来指向不同的块，如果要找的元素在上一块上就要去找上一块的起始位置，然后往后按顺序找，但是这样不会效率很低吗？总是要在不同的块上找…“

👨‍🚀小明(惊讶)：“没错没错，这都让你发现了，但是这正是我们接下来要讲的–deque的缺陷”

📌deque的缺陷

👨‍🚀小明：“

✨与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。

✨与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

✨但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。

”

🧚小星：“哦~高不成低不就呗，但是为什么要将它作为stack和queue的底层数据结构啊？它不是效率低吗？”（大写的问号）

👨‍🚀小明（邪魅一笑）：“还挺警觉，是这样的…👇”

🎈为什么选择deque作为stack和queue的底层默认容器？

✨stack是一种后进先出的特殊线性数据结构，因此**只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，**比如vector和list都可以；

✨queue是先进先出的特殊线性数据结构，**只要具有push_back和pop_front操作的线性结构，都可以作为queue的底层容器，**比如list。

✨但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：

1. **stack和queue不需要遍历(**因此stack和queue没有迭代器)，只需要在固定的一端或者两端进行操作。
2. 在stack中元素增长时，deque比vector的效率高(扩容时不需要搬移大量数据)；queue中的元素增长时，deque不仅效率高，而且内存使用率高。结合了deque的优点，而完美的避开了其缺陷。

🧚小星：“哦哦懂了，早说嘛~，你之前又没说stack和queue是什么(心想可恶就知道卖弄)”

👨‍🚀小明：“好了好了，正经教了，接下来就要介绍stack&queue的概念和使用了，坐好发车了~”

📍stack的介绍和使用

🎈stack的介绍

👨‍🚀小明：“这里我们先看一下文档是怎么说的。总结就是下面几点。”

stack文档

1. ✨stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。
2. ✨stack是作为容器适配器被实现的，这里在前情提要里讲过了，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
3. ✨stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下操作：

• empty：判空操作
• back：获取尾部元素操作
• push_back：尾部插入元素操作
• pop_back：尾部删除元素操作

4. ✨标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器，默认情况下使用deque。

👨‍🚀小明给小星展示了一张表“它的常用函数有下面这些，每一个都是链接了文档的超链接，想了解更多就点它，后面接口说明有功能介绍”

🎈stack的常用函数

✨函数说明	✨接口说明
✨stack()	✨构造空的栈
✨empty()	✨检测stack是否为空
✨size()	✨返回stack中元素的个数
✨top()	✨返回栈顶元素的引用
✨push()	✨将元素val压入stack中
✨pop()	✨将stack中尾部的元素弹出

🎈stack的使用

👨‍🚀小明：“在前面介绍了函数的功能，是不是觉得很简单？（又想考验小星了）”

🧚小星：“就这？我幼儿园都能学会（叉腰）”

👨‍🚀小明：“好，那我就给你出几道题，你做做（呵，鱼儿上钩了）”

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

• MinStack() 初始化堆栈对象。
• void push(int val) 将元素val推入堆栈。
• void pop() 删除堆栈顶部的元素。
• int top() 获取堆栈顶部的元素。
• int getMin() 获取堆栈中的最小元素。

示例 1:

输入：

[“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”]
[[],[-2],[0],[-3],[],[],[],[]]

输出：

[null,null,null,null,-3,null,0,-2]

解释：

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.

提示：

-2³¹ <= val <= 2³¹ - 1
pop、top 和 getMin 操作总是在 非空栈 上调用
push, pop, top, and getMin最多被调用 3 * 10⁴ 次

接口是这样的：

class MinStack {
public:
    MinStack() {

    }
    
    void push(int val) {

    }
    
    void pop() {

    }
    
    int top() {

    }
    
    int getMin() {

    }
};

🧚小星陷入了思考：“又要是栈，又要在常数时间内检索最小值，常数时间内检索说明是有东西存着它的，诶，我可以另外定义一个栈来存它的最小值，对！只要从第一个数入栈开始，以后的每一个比前一个小的数就入栈，在出栈的时候就判断是否是当前最小值，是就一起出栈，不是，则保留最小值的那个栈就不出栈，嗯，没错，果然天才如我哈哈哈。”

写出代码如下：

class MinStack {
public:
    MinStack() {

    }
    
    void push(int val) {
        use.push(val);
        if(rem.empty()||rem.top()>=val)
        {
            rem.push(val);
        }
    }
    
    void pop() {
        if(rem.top()==use.top())
        {
            rem.pop();
        }
        use.pop();
    }
    
    int top() {
        return use.top();
    }
    
    int getMin() {
        return rem.top();
    }
private:
    stack<int>use;
    stack<int>rem;
};

过了

👨‍🚀小明此时呆住：心想：“我去，这小子有点子天赋啊，我当年可没这么快想出来，不过为了不让他骄傲，得打击他一下，对，我绝不是腹黑”

于是说：“啧啧啧，这么简单的题还用想？我亲爱的蠢弟弟，居然用了十分钟，就我当年一层的水平吧~来看看下一题，这题可不能这么慢了嗷”

🧚小星心想“二哥这么厉害的么，看来我得努力了”，下题给他眼前一亮哼哼“

于是说：”欧克欧克，没问题！“

👨‍🚀小明给出了第二题。

第二题如下：

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。请你计算该表达式。返回一个表示表达式值的整数。

注意：

有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
每个操作数（运算对象）都可以是一个整数或者另一个表达式。
两个整数之间的除法总是 向零截断 。
表达式中不含除零运算。
输入是一个根据逆波兰表示法表示的算术表达式。
答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：

输入：tokens = [“2”,“1”,“+”,“3”,“*”]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = [“4”,“13”,“5”,“/”,“+”]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = [“10”,“6”,“9”,“3”,“+”,“-11”,““,”/“,””,“17”,“+”,“5”,“+”]
输出：22

解释：该算式转化为常见的中缀算术表达式为：
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：

1 <= tokens.length <= 104
tokens[i] 是一个算符（“+”、“-”、“*” 或 “/”），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点：

去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

🧚小星这下有点懵了，计算逆波兰表示法 表示的算术表达式？？？，大写的问号好吧。

👨‍🚀小明看出来小星不会了说：”其实没你想的那么难，一个公式把你唬住了而已（摇摇头），

这道题的思路其实非常清晰，只需要使用栈来模拟整个计算过程即可。

具体来说，我们遍历 tokens 中的每个字符串，判断当前字符是操作符还是数字：

如果当前字符是数字，将其转换为整数并压入栈中；

否则，从栈顶弹出两个数字进行计算，然后把结果压入栈中。

最后，我们只需返回栈顶元素即可得到表达式的值。

需要注意的地方是，整数除法总是向零截断。

此外，如果 tokens 列表为空，则应直接返回0。

这不就解出来了吗？“

代码如下：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        long long res;
        stack<int> st1;
        for(auto e : tokens)
        {
            if(e=="+"||e=="-"||e=="*"||e=="/")
            {
                long long right=st1.top();
                st1.pop();
                long long left=st1.top();
                st1.pop();
                switch(e[0])
                {
                    case '+':st1.push(left+right);
                            break;
                    case '-':st1.push(left-right);
                            break;
                    case '*':st1.push((int)(left*right));
                            break;
                    case '/':st1.push(left/right);
                            break;
                }
            }
            else
            {
                st1.push(stoll(e));
            }
        }
        return st1.top();
    }
};

🧚小星心想姜还是老的辣，但是嘴上还是不松口:”哦哦就是这样啊，我会了”

👨‍🚀小明看着他傲娇的样子也不说破：”明白就好，下面就开始讲queue的基础知识了，后面再讲怎么把他们模拟实现。“

📍queue的介绍和使用

👨‍🚀小明：“这里我们先看一下文档是怎么说的。总结就是下面几点。”

🎈queue的介绍

queue的文档介绍

1. ✨队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。

2. ✨队列作为容器适配器实现，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从队尾入队列，从队头出队列。

3. ✨底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作:

• empty：检测队列是否为空
• size：返回队列中有效元素的个数
• front：返回队头元素的引用
• back：返回队尾元素的引用
• push_back：在队列尾部入队列
• pop_front：在队列头部出队列

4. ✨标准容器类deque和list满足了这些要求。默认情况下，如果没有为queue实例化指定容器类，则使用标准容器deque。

👨‍🚀小明又给小星展示了一张表“它的常用函数有下面这些，每一个都是链接了文档的超链接，想了解更多就点它，后面接口说明有功能介绍”

🎈queue的常用函数

✨函数声明	✨接口说明
✨queue()	✨构造空的队列
✨empty()	✨检测队列是否为空，是返回true，否则返回false
✨size()	✨返回队列中有效元素的个数
✨front()	✨返回队头元素的引用
✨back()	✨返回队尾元素的引用
✨push()	✨在队尾将元素val入队列
✨pop()	✨将队头元素出队列

🎈queue的使用

👨‍🚀小明：”按照惯例，现在该做题练练手了“

🧚小星又恢复了活力，双手叉腰、鼻孔朝天道：”来吧，小小队列题“

👨‍🚀小明心想可不能打击他的士气，万一不学了就不好了，于是找到了这题：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

• void push(int x) 将元素 x 压入栈顶。
• int pop() 移除并返回栈顶元素。
• int top() 返回栈顶元素。
• boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

• 你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
• 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

• 1 <= x <= 9
• 最多调用100 次 push、pop、top 和 empty
• 每次调用 pop 和 top 都保证栈不为空

接口如下：

class MyStack {
public:
    MyStack() {

    }
    
    void push(int x) {

    }
    
    int pop() {

    }
    
    int top() {

    }
    
    bool empty() {

    }
};

🧚小星脑袋极速运转：”用队列实现栈的功能，队列是先进先出，栈是先进后出，那么就需要两个队列，要把进入的数据倒来倒去，让后面的到前面就好了，其他的功能也是类似，把握好数据的顺序就可以了，这么简单？不愧是我，“

代码如下：

class MyStack {
public:
    MyStack() {

    }
    
    void push(int x) {
        if(q1.empty())
        {
            q1.push(x);
            while(!q2.empty())
            {
                q1.push(q2.front());
                q2.pop();
            }
        }
        else
        {
            q2.push(x);
            while(!q1.empty())
            {
                q2.push(q1.front());
                q1.pop();
            }
        }
    }
    
    int pop() {
        if(q1.empty())
        {
            int res=q2.front();
            q2.pop();
            return res;
        }
        else
        {
            int res=q1.front();
            q1.pop();
            return res;
        }
    }
    
    int top() {
        if(q1.empty())
        {
            int res=q2.front();
            return res;
        }
        else
        {
            int res=q1.front();
            return res;
        }
    }
    
    bool empty() {
        return q1.empty()&&q2.empty();
    }
private:
    queue<int> q1;
    queue<int> q2;
};

过了

👨‍🚀小明：”嗯嗯，孺子可教也，不错，看来有点天赋的“（其实都在我的掌控之中）

🧚小星：”哼哼，不看看我是谁（得意）“

👨‍🚀小明：”那到是，厉害厉害~下面就要讲一个有点点难的东西了，不过我觉得以你的智商应该很简单吧“

🧚小星：”你尽管讲，那年我双手插兜，不知道什么是对手。“

👨‍🚀小明忍住不笑：”好，那就开始讲priority_queue优先队列。“

📍priority_queue的介绍和使用

👨‍🚀小明：“这里我们先看一下文档是怎么说的。总结就是下面几点。”

🎈priority_queue的介绍

priority_queue文档介绍

1. ✨优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
2. ✨此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
3. ✨优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。
4. ✨底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过随机访问迭代器访问，并支持以下操作：

• empty()：检测容器是否为空
• size()：返回容器中有效元素个数
• front()：返回容器中第一个元素的引用
• push_back()：在容器尾部插入元素
• pop_back()：删除容器尾部元素

5. ✨标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue类实例化指定容器类，则使用vector。
6. ✨**需要支持随机访问迭代器，以便始终在内部保持堆结构。**容器适配器通过在需要时自动调用算法函数make_heap、push_heap和pop_heap来自动完成此操作。

👨‍🚀小明又给小星展示了一张表“它的常用函数有下面这些，每一个都是链接了文档的超链接，想了解更多就点它，后面接口说明有功能介绍”

🧚小星：”又是熟悉的操作“

小明提醒道：”优先级队列默认使用vector作为其底层存储数据的容器，

在vector上又使用了堆算法将vector中元素构造成堆的结构，

因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用

priority_queue。注意：默认情况下priority_queue是大堆。你知道堆吧？“

🧚小星：”当然，我记得是这样的，

如果有一个关键码的集合K={k0,k1,k2,k3,……k(n-1)}

把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，

并满足：Ki<=K(2i+1)且Ki<=K(2i+2)，

或者说Ki>=K(2i+1)且Ki>=K(2i+2)，

i=0,1,2…,则称为小堆（或大堆）。

将根节点最大的堆叫做最大堆或大根堆

根节点最小的堆叫做最小堆或小根堆

，我看过这篇博客《堆》“

👨‍🚀小明：”可以的，知道就好，看来知道的不少，那我们接着讲“

🎈priority_queue的常用函数

函数声明	接口说明
✨priority_queue()/priority_queue(first,last)	✨构造一个空的优先级队列
✨empty()	✨检测优先级队列是否为空，是返回true，否则返回false
✨top()	✨返回优先级队列中最大(最小元素)，即堆顶元素
✨push(x)	✨在优先级队列中插入元素x
✨pop()	✨删除优先级队列中最大(最小)元素，即堆顶元素

🎈priority_queue的使用

👨‍🚀小明：”我们现在知道它默认是大堆，那么如果想建小堆怎么办？我们来看看文档里它的参数“

🧚小星（诶，默认是大堆，第三个参数是less，也就是说小堆，第三个参数就相反，哦~我明白了）：“把第三个参数改为相反的就可以了”

👨‍🚀小明：”诶呦，不错哦，还会抢答了，你说的没错，如果需要建小堆参考下面代码。“

#include <iostream>
using namespace std;
#include <vector>
#include <queue>
#include <functional> // greater算法的头文件
int main(){
        // 默认情况下，创建的是大堆，其底层按照小于号比较
        vector<int> v{3,2,7,6,0,4,1,9,8,5};
        priority_queue<int> q1;
        for (auto& e : v)
        q1.push(e);
        cout << q1.top() << endl;
        // 如果要创建小堆，将第三个模板参数换成greater比较方式
        priority_queue<int, vector<int>, greater<int>> q2(v.begin(), v.end());
        cout << q2.top() << endl;

        return 0;
}

👨‍🚀小明：”greater算法代码是这样的“

template <typename Ty>
struct greater {
    __device__ __forceinline__ Ty operator()(Ty arg1, Ty arg2) const {
        return (arg1 < arg2) ? arg2 : arg1;
    }
};

🧚小星：”懂了懂了，根本难不倒我，下一个！“

👨‍🚀小明笑了：”好啊，现在有这么一个情况，这是优先队列，也就是堆，可以找出最大值或者最小值，那么假如说元素是日期，你怎么比较它们的大小呢，怎么让它们建堆呢？“

🧚小星：”日期包括年月日，直接比是不行的，之前学过类和对象，我可以包装一个日期类，比较对象大小的话，就要分别比较年月日，那么就要重载操作符，对就是这样，然后…嗯用日期对象建堆就好了，代码可以这么写…“

class Date
{
    public:
    Date(int year = 1900, int month = 1, int day = 1)
        : _year(year)
            , _month(month)
            , _day(day)
        {}
    bool operator<(const Date& d)const
    {
        return (_year < d._year) ||
            (_year == d._year && _month < d._month) ||
            (_year == d._year && _month == d._month && _day < d._day);
    }
    bool operator>(const Date& d)const
    {
        return (_year > d._year) ||
            (_year == d._year && _month > d._month) ||
            (_year == d._year && _month == d._month && _day > d._day);
    }
    friend ostream& operator<<(ostream& _cout, const Date& d)
    {
        _cout << d._year << "-" << d._month << "-" << d._day;
        return _cout;
    }
    private:
    int _year;
    int _month;
    int _day;
};
void TestPriorityQueue()
{
    // 大堆，需要用户在自定义类型中提供<的重载
    priority_queue<Date> q1;
    q1.push(Date(2018, 10, 29));
    q1.push(Date(2018, 10, 28));
    q1.push(Date(2018, 10, 30));
    cout << q1.top() << endl;
    // 如果要创建小堆，需要用户提供>的重载
    priority_queue<Date, vector<Date>, greater<Date>> q2;
    q2.push(Date(2018, 10, 29));
    q2.push(Date(2018, 10, 28));
    q2.push(Date(2018, 10, 30));
    cout << q2.top() << endl;
}

🧚小星歪嘴笑道：”轻而易举~“

👨‍🚀小明：”非常不错，说到类和对象我给你讲个笑话，有一天我碰到了圣诞老人

我：“我想要条龙。”

圣诞老人：“你他妈现实点。”

我：“我想要对象。”

圣诞老人：“你要什么颜色的龙？”

“

🧚小星：”？？？，有那么难吗？我给你new一个“

👨‍🚀小明脸黑：”你gun，继续继续，接下来做个题巩固一下“

🧚小星：”笑死哈哈哈“

题目如下：

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1:
输入: [3,2,1,5,6,4], k = 2
输出: 5

示例 2:
输入: [3,2,3,1,2,4,5,5,6], k = 4
输出: 4

提示：

1 <= k <= nums.length <= 10⁵
-10⁴ <= nums[i] <= 10⁴

🧚小星：”学完优先队列，这题一看就会，直接建大堆，把前面k-1个pop掉就好了，代码这样写“

class Solution {
    public:
    int findKthLargest(vector<int>& nums, int k) {
        // 将数组中的元素先放入优先级队列中
        priority_queue<int> p(nums.begin(), nums.end());
        // 将优先级队列中前k-1个元素删除掉
        for(int i= 0; i < k-1; ++i)
        {
            p.pop();
        }
        return p.top();
    }
};

👨‍🚀小明已经心累，不想讲了，丢给小星一份资料：”这是他们的模拟实现，里面有注释，你自己看吧，我想静静“

🧚小星偷笑单身狗：”okk，没嘚问题，不过静静是谁（一肚子坏水）“

👨‍🚀小明：”…“

📍stack&queue&priority_queue模拟实现

🎈stack模拟实现：

#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
using namespace std;
namespace hxq
{
    template<class T, class Container = std::deque<T>>  // 定义模板类 stack，可以指定 T 类型和 Container 容器类型（默认为 deque）
        class stack
        {
            public:
            void push(const T& x)  // 在栈顶插入元素
            {
                _con.push_back(x);  // 使用容器的 push_back() 方法
            }

            void pop()  // 删除栈顶元素
            {
                _con.pop_back();  // 使用容器的 pop_back() 方法
            }

            T& top()  // 访问栈顶元素
            {
                return _con.back();  // 使用容器的 back() 方法
            }

            const T& top() const  // 访问栈顶元素（常量引用版本，用于 const 对象）
            {
                return _con.back();  // 使用容器的 back() 方法
            }

            bool empty()  const  // 判断栈是否为空
            {
                return _con.empty();  // 使用容器的 empty() 方法
            }

            size_t size() const  // 返回栈的大小
            {
                return _con.size();  // 使用容器的 size() 方法
            }
            private:
            Container _con;  // 使用模板类型参数指定容器类型
        };
}

🎈queue模拟实现

#include <iostream>
#include <stack>  
#include <queue>  
#include <vector>  
#include <list>  
#include <algorithm>  
#include <functional>  
using namespace std;
namespace hxq
{
    template<class T, class Container = std::deque<T>>  // 定义模板类 hxq，可以指定 T 类型和 Container 容器类型（默认为 deque）
    class hxq
    {
    public:
        void push(const T& x)  // 将元素插入容器
        {
            _con.push_back(x);  // 使用容器的 push_back() 方法
        }

        void pop()  // 删除容器中的第一个元素
        {
            _con.pop_front();  // 使用容器的 pop_front() 方法
        }

        T& back()  // 访问容器中最后一个元素
        {
            return _con.back();  // 使用容器的 back() 方法
        }

        T& front()  // 访问容器中第一个元素
        {
            return _con.front();  // 使用容器的 front() 方法
        }

        const T& back() const  // 访问容器中最后一个元素（常量引用版本，用于 const 对象）
        {
            return _con.back();
        }

        const T& front() const  // 访问容器中第一个元素（常量引用版本，用于 const 对象）
        {
            return _con.front();
        }

        bool empty()  const  // 判断容器是否为空
        {
            return _con.empty();  // 使用容器的 empty() 方法
        }

        size_t size() const  // 返回容器中元素的个数
        {
            return _con.size();  // 使用容器的 size() 方法
        }
    private:
        Container _con;  // 使用模板类型参数指定容器类型
    };
}

🎈priority_queue模拟实现

#include <iostream> 
#include <stack>  
#include <queue>  
#include <vector> 
#include <list>  
#include <algorithm> 
#include <functional>  

using namespace std;
namespace hxq
{
    template<class T, class Container = vector<T>, class Compare = std::less<T>>
        // 优先队列类 hxq，可以指定 T 类型和 Container 容器类型（默认为 vector），Compare类型默认为小于号比较
        class priority_queue
        {
            public:
            priority_queue()
            {}

            // 模板构造函数，可以使用迭代器区间初始化堆容器
            template <class InputIterator>
                priority_queue(InputIterator first, InputIterator last)
            {
                while (first != last)
                {
                    _con.push_back(*first);  // 将元素插入容器
                    ++first;
                }

                // 建堆，从最后一个非叶节点开始，自底向上调整直至节点0
                for (int i = (_con.size()-1-1)/2; i >= 0; --i)
                {
                    adjust_down(i);
                }
            }

            // 对 child 所在的节点进行向上调整操作，维护堆的性质
            void adjust_up(size_t child)
            {
                Compare com;  // 定义比较方式
                size_t parent = (child - 1) / 2;  // 计算父节点的下标
                while (child > 0)  // 当 child 不为堆顶节点时，不断向上调整
                {
                    if (com(_con[parent], _con[child]))  // 如果父节点小于子节点，则进行交换操作
                    {
                        std::swap(_con[child], _con[parent]);
                        child = parent;
                        parent = (child - 1) / 2;
                    }
                    else  // 否则跳出循环
                    {
                        break;
                    }
                }
            }

            // 往优先队列中插入元素 x，并进行向上调整操作
            void push(const T& x)
            {
                _con.push_back(x);  // 插入元素
                adjust_up(_con.size() - 1);  // 向上调整
            }

            // 对 parent 所在的节点进行向下调整操作，维护堆的性质
            void adjust_down(size_t parent)
            {
                Compare com;  // 定义比较方式
                size_t child = parent * 2 + 1;  // 计算左孩子节点的下标
                while (child < _con.size())  // 当左孩子存在时，不断向下调整
                {
                    // 选出左右孩子中较大（或较小）的那一个
                    if (child + 1 < _con.size() && com(_con[child],_con[child + 1]))
                    {
                        ++child;
                    }

                    if (com(_con[parent],_con[child]))  // 如果父节点小于子节点，则进行交换操作
                    {
                        std::swap(_con[child], _con[parent]);
                        parent = child;
                        child = parent * 2 + 1;
                    }
                    else  // 否则跳出循环
                    {
                        break;
                    }
                }
            }

            // 弹出堆顶元素，并在弹出之前进行向下调整操作
            void pop()
            {
                std::swap(_con[0], _con[_con.size() - 1]);  // 将堆顶元素和最后一个元素交换
                _con.pop_back();  // 弹出最后一个元素

                adjust_down(0);  // 向下调整堆顶节点
            }

            // 返回优先队列中堆顶元素的引用
            const T& top()
            {
                return _con[0];
            }

            // 判断容器是否为空
            bool empty()  const
            {
                return _con.empty();
            }

            // 返回容器中元素的个数
            size_t size() const
            {
                return _con.size();
            }

            private:
            Container _con;  // 使用模板类型参数指定容器类型
        };
}

👨‍🚀小明：”今天我们就到这吧…“

🧚小星：”你答应我要唱歌、跳舞、Rap、打篮球的“

👨‍🚀小明：”呵呵，好好看，好好学“

🧚小星满眼星星

全剧终

📍后记

学习stack&queue&priority_queue基础知识及其模拟实现。

感谢大家支持！！！

respect！

下篇见！