目录
一、简介
（一）stack类
在 C++ 中，stack（栈）类是一个容器适配器，它被定义在<stack>头文件中。容器适配器是一种设计模式（就是把解决问题的经验总结出来），它允许将一个已有的容器类（如 vector、list或deque）转换为另一种容器类型的接口，在stack的情况下，以其他类型的容器为基础，并与提供栈这种数据结构相关操作的接口进行封装。具体声明如下：
类模板第一个参数是类型，第二个参数为适配器，默认为deque。
（二）queue类
在 C++ 中，queue（队列）类也是一个容器适配器，它提供了队列这种数据结构的功能。它被定义在<queue>头文件中，像stack一样，queue也是基于其他底层容器（如deque、list）来实现的，默认底层容器是deque。具体声明如下：
类模板第一个参数是类型，第二个参数为适配器，默认为deque。
二、使用与模拟实现
stack类与queue类的接口比较简单，因为要保证数据的后进先出/先进先出的属性，所以不提供迭代器。（设计迭代器的话就可以遍历到栈中的每一个元素，就能进行随机插入与删除，违反了后进先出/先进先出的理念）
（一）stack类
1、使用
stack类本质是实现栈的功能，即具备先进后出的属性与相关接口，具体如下：
| 函数说明 | 接口说明 |
|---|---|
|
stack()
|
构造空的栈
|
|
empty()
|
检测 stack 是否为空
|
|
size()
|
返回 stack 中元素的个数
|
|
top()
|
返回栈顶元素的引用
|
|
push()
|
将元素 val 压入 stack 中
|
|
pop()
|
将 stack 中尾部的元素弹出
|
示例代码如下：
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stack>
#include<queue>
#include<vector>
using namespace std;
void test01()
{
stack<int, vector<int>> st;
for (size_t i = 1; i < 5; i++)
{
st.push(i);
}
cout << "empty():" << st.empty() << endl;
cout << "size():" << st.size() << endl;
//遍历
cout << "遍历：" << endl;
for (size_t i = 1; i < 5; i++)
{
cout << st.top() << " ";
st.pop();
}
cout << endl;
}
int main()
{
test01();
return 0;
}结果如下：
注意：栈的遍历只能是一边出一边看。
2、OJ题
（1）最小栈
思路：创建一个正常的栈和一个值插入比自己头元素小的值的栈（为空要插入一次）。
代码如下：
class MinStack {
public:
//该构造不写也行，用系统自动生成的无参构造
MinStack() {
//无参构造中的自定义类型会在初始化列表调用他们自己的构造
}
void push(int val) {
_st.push(val);
if(_minst.empty() || val <= _minst.top())
_minst.push(val);
}
void pop() {
if(_st.top() == _minst.top())
_minst.pop();
_st.pop();
}
int top() {
return _st.top();
}
int getMin() {
return _minst.top();
}
private:
stack<int> _st;
stack<int> _minst;
};（2）栈的弹出压入序列
解题思路：
① 创建一个栈；
② 给入栈数组给一个指针pushi，先入栈pushi位置的数据，pushi++；
③ 给出栈数组给一个指针popi，栈顶数据跟popi位置序列数据比较，若果匹配则出栈，popi++，回到第二步；不匹配或栈为空则回到第一步。（不匹配是后面才出栈）；
④ 到了最后，pushi等于pushV.size()，若全部匹配，则栈是空的，判空的结果与返回的结果一致；若不匹配则栈不为空。
代码如下：
bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
size_t pushi = 0;
size_t popi = 0;
stack<int> st;
while(pushV.size()>pushi)
{
st.push(pushV[pushi++]);
while(!st.empty() && popV[popi] == st.top())
{
st.pop();
popi++;
}
}
return st.empty();
}（3）逆波兰表达式求值
解题思路：
① 若为操作数则入栈；
② 若为操作符，则取栈顶两个操作数运算，运算结果继续入栈；（先取出来的是右操作数，因为栈的先进后出原则）
③ 最后一个栈元素就是运算结果。
代码如下：
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int> s;
for(auto& str : tokens)
{
if(!(str=="+" || str=="-" || str=="*" || str=="/"))
{
//操作数则入栈
s.push(stoi(str));
}
else
{
//操作符，取栈顶两元素进行运算
int right = s.top();
s.pop();
int left = s.top();
s.pop();
switch(str[0])
{
case '+':
s.push(left + right);
break;
case '-':
s.push(left - right);
break;
case '*':
s.push(left * right);
break;
case '/':
s.push(left / right);
break;
}
}
}
return s.top();
}
};注意：
① 操作符是一个字符，从string里取出来的操作符在case中要用' '进行引用。
② 因为操作数可能是多位或者是负数，所以使用中括号加下标的形式进行使用操作数的话可能要把他们拼在一起，非常麻烦，所以直接使用stoi把string匿名对象的内容直接转为整形。
3、模拟实现
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<vector>
#include<deque>
namespace zyb
{
template<class T, class Container = deque<T>>//半缺省模板参数
class stack
{
public:
//不用接构造函数，因为会调用其他结构的默认构造
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_back();
}
T& top()
{
return _con.back();
}
size_t size() const // 指向的内容不能修改
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
Container _con;//使用其他结构来作为栈的结构
};
}
测试代码如下：
void test01()
{
zyb::stack<int> st;
for (size_t i = 0; i < 5; i++)
{
st.push(i);
}
cout << "size():" << st.size() << endl;
cout << "top():" << st.top() << endl;
cout << "empty():" << st.empty() << endl;
while (!st.empty())
{
cout << st.top() << " ";
st.pop();
}
}结果如下所示：
注意：把传入容器的尾部当做栈顶，对栈进行插入删除操作时直接push_back与pop_back即可，若要获取栈顶元素，使用back()这种通用型接口即可获得栈顶元素。
（二）queue类
1、使用
queue类本质是实现队列的功能，即具备先进先出的属性与相关接口，具体如下：
示例代码如下：
void test02()
{
queue<int> q;
for (size_t i = 1; i < 5; i++)
{
q.push(i);
}
cout << "empty():" << q.empty() << endl;
cout << "size():" << q.size() << endl;
cout << "front():" << q.front() << endl;
cout << "back():" << q.back() << endl;
//遍历
cout << "遍历：" << endl;
for (size_t i = 1; i < 5; i++)
{
cout << q.front() << " ";
q.pop();
}
cout << endl;
}
int main()
{
test02();
return 0;
}运行结果如下：
2、模拟实现
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<deque>
namespace zyb
{
template<class T, class Container = deque<T>>//半缺省模板参数
class queue
{
public:
//不用接构造函数，因为会调用其他结构的默认构造
void push(const T& x)
{
_con.push_back(x);
}
void pop()
{
_con.pop_front();
}
T& front()
{
return _con.front();
}
T& back()
{
return _con.back();
}
size_t size() const // 指向的内容不能修改
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
Container _con;//使用其他结构来作为栈的结构
};
}
测试代码如下：
void test02()
{
zyb::queue<int> q;
for (size_t i = 0; i < 5; i++)
{
q.push(i);
}
cout << "size():" << q.size() << endl;
cout << "front():" << q.front() << endl;
cout << "back():" << q.back() << endl;
cout << "empty():" << q.empty() << endl;
while (!q.empty())
{
cout << q.front() << " ";
q.pop();
}
}结果如下所示：
注意：
① 队列不能使用vector进行适配，因为vector不支持头删。
② 在测试类中要先展开命名空间再引入stack或queue类模板（两个模拟实现类中没展开命名空间std），因为头文件展开后找不到展开的命名空间std，deque找不到出处，会报错。（在vs中写在头文件下面也没事，因为头文件处只是一个类模板，没有实例化，在编译时只做简单的检测，在进行业务处理的时候进行实例化再检查，发现已有命名空间，所以不会报错）
三、priority_queue类
在 C++ 中，priority_queue（优先队列，堆）类是一种特殊的队列容器适配器，根据严格的弱排序标准（less），它的第一个元素总是它所包含的元素中最大的。
类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素，默认大根堆（比较逻辑使用仿函数less）)。具体声明如下：
（一）使用
优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。
注意：默认情况下priority_queue是大堆。
|
函数声明
|
接口说明
|
|---|---|
|
priority_queue()
priority_queue(first, last)
|
构造一个空的优先级队列 / 使用迭代器范围构造优先级队列
|
|
empty( )
|
检测优先级队列是否为空，是返回 true ，否 则返回 false
|
|
top( )
|
返回优先级队列中最大 ( 最小元素 ) ，即堆顶元 素
|
|
push(x)
|
在优先级队列中插入元素 x
|
|
pop()
|
删除优先级队列中最大 ( 最小 ) 元素，即堆顶元 素
|
（二）OJ题
1、数组中第K个大的元素
解题思路：根据优先队列的特性，pop出来的都是最大的元素，则可先pop前k-1个元素，最后再取top元素。
代码如下：
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
//建堆(默认大堆，出的也是大的数字)
priority_queue<int> p(nums.begin(), nums.end());
while(--k)
{
p.pop();//把前k-1个最大的数删掉
}
return p.top();//在栈顶的就是最大的那个
}
};（三）模拟实现
此代码为小堆的模拟实现：
#pragma once
#include<iostream>
#include<vector>
namespace zyb
{
template<class T, class Container = vector<T>>
class priority_queue//小堆
{
public:
void AdjustUp(int child)
{
int parent = (child - 1) / 2;
while (child > 0)
{
if (_con[child] < _con[parent])
{
swap(_con[child], _con[parent]);
child = parent;//更新下标
parent = (parent - 1) / 2;
}
else
break;
}
}
void push(const T& x)//插入一个数据后要使用向上调整算法佬保持堆的结构
{
_con.push_back(x);//尾插数据
//进行向上调整算法
AdjustUp(_con.size() - 1);
}
void AdjustDowm(int parent)
{
int child = parent * 2 + 1;
while (child < _con.size())
{
if (child + 1 < _con.size() && _con[child] > _con[child + 1])//孩子节点对比，选出较小的一个(因为是小根堆，父亲节点要小)
child++;
if (_con[parent] > _con[child])//交换父节点与孩子节点，移动节点位置
{
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}
void pop()//删除，先把堆顶元素与堆尾元素交换，删除堆尾元素，再进行向下调整算法
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDowm(0);
}
bool empty()
{
return _con.empty();
}
const T& top()
{
return _con[0];
}
size_t size()
{
return _con.size();
}
private:
Container _con;
};
}
测试代码如下：
void test03()
{
zyb::priority_queue<int> pq;//小堆
for (size_t i = 0; i < 5; i++)
{
pq.push(i);
}
cout << "size():" << pq.size() << endl;
cout << "top():" << pq.top() << endl;
cout << "empty():" << pq.empty() << endl;
while (!pq.empty())
{
cout << pq.top() << " ";
pq.pop();
}
}其结果为：
四、deque类（了解）
（一）原理介绍
deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与 list比较，空间利用率比较高。
deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底层结构如下图所示：
双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示：
那deque是如何借助其迭代器维护其假想连续的结构呢？ 如下图所示：
（二）deque缺陷
与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率比vector高的。
与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。
但是，deque有一个致命缺陷：不适合遍历。因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为stack和queue的底层数据结构。
（三）做底层默认容器
stack是一种后进先出的特殊线性数据结构，因此只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如vector和list都可以；queue是先进先出的特殊线性数据结构，只要具有push_back()和pop_front()操作的线性结构，都可以作为queue的底层容器，比如 list。但是STL中对stack和queue默认选择deque作为其底层容器，主要是因为：
① stack和queue不需要遍历（stack和queue没有迭代器，避开了deque的缺点），只需要在固定的一端或者两端进行操作。
② 在stack中元素增长时，deque比vector的效率高（体现在扩容时不需要搬移大量数据）；queue中的元素增长时，deque不仅效率高，而且内存使用率高。
结合了deque的优点，而完美的避开了其缺陷。
五、仿函数
（一）概念
仿函数是一种可以像函数一样使用的对象。在 C++ 中，通过重载()运算符来实现。它的行为就像一个函数，但实际上是一个类的实例。如下代码所示：
template <class T>
struct Less
{
boole operator()(const T& x, const T& y)const
{
return x < y;
}
};
int main()
{
Less<int> lessFunc;
cout << lessFunc(1, 2) << endl;
return 0;
}
（二）在priority_queue中的使用
priority_queue类模板中第三个模板参数就是仿函数，默认使用less仿函数。
less是 C++ 标准库<functional>头文件中定义的一个仿函数模板。它用于比较两个对象，判断第一个对象是否小于第二个对象。如下代码所示：
template <class T>
struct less//仿函数类模板
{
bool operator()(const T& x, const T& y) const
{
return x < y;
}
};在priority_queue中的比较大小的逻辑就可以使用仿函数进行比较大小，如：
//if (_con[child] < _con[parent])
if (com(_con[child], _con[parent]))//使用仿函数替代比较逻辑这样相当于对比较运算符做了一次“参数化”，仿函数传什么比较运算符就使用什么。
（三）使用仿函数后的priority_queue模拟实现
此模拟实现为默认的大堆（less仿函数） ：
#pragma once
#include<iostream>
#include<vector>
namespace zyb
{
template <class T>
struct less//仿函数less类模板
{
bool operator()(const T& x, const T& y) const
{
return x < y;
}
};
template <class T>
struct greater//仿函数greater类模板
{
bool operator()(const T& x, const T& y)const
{
return x > y;
}
};
template<class T, class Container = vector<T>, class Compare = less<int>>
class priority_queue
{
public:
//强制生成默认构造
priority_queue() = default;
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last)//迭代区间构造
:_con(first, last)
{
// 从最后一个叶子节点开始建堆
for (int i = (_con.size() - 2) / 2; i >= 0; i--)
{
AdjustDowm(i);
}
}
void AdjustUp(int child)
{
Compare com;
int parent = (child - 1) / 2;
while (child > 0)
{
//if (_con[parent] < _con[child])
if (com(_con[parent], _con[child]))//使用仿函数替代比较逻辑
{
swap(_con[child], _con[parent]);
child = parent;//更新下标
parent = (parent - 1) / 2;
}
else
break;
}
}
void push(const T& x)//插入一个数据后要使用向上调整算法佬保持堆的结构
{
_con.push_back(x);//尾插数据
//进行向上调整算法
AdjustUp(_con.size() - 1);
}
void AdjustDowm(int parent)
{
Compare com;
int child = parent * 2 + 1;
while (child < _con.size())
{
//孩子节点对比，选出较大的一个(因为是大根堆，父亲节点要大)
//if (child + 1 < _con.size() && _con[child] < _con[child + 1])
if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
child++;
//交换父节点与孩子节点，移动节点位置
//if (_con[parent] < _con[child])
if (com(_con[parent], _con[child]))
{
swap(_con[parent], _con[child]);
parent = child;
child = parent * 2 + 1;
}
else
break;
}
}
void pop()//删除，先把堆顶元素与堆尾元素交换，删除堆尾元素，再进行向下调整算法
{
swap(_con[0], _con[_con.size() - 1]);
_con.pop_back();
AdjustDowm(0);
}
bool empty()
{
return _con.empty();
}
const T& top()
{
return _con[0];
}
size_t size()
{
return _con.size();
}
private:
Container _con;
};
}
注意：一般情况下，显示写了有参数但不是全缺省的构造函数后就不会自动生成构造函数，但这样就缺少了默认构造（不用传参数的构造函数），在使用上会有不便利的地方。可以使用如下代码解决问题：
priority_queue() = default;
这条代码的意思是强制生成默认构造。
（四）使用仿函数的情况
① 当一个类不支持比较大小，就可以写仿函数来进行比较。如下代码所示：
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
// 自定义的类，不支持比较大小
class Person {
public:
string name;
int age;
Person(const std::string& n, int a) : name(n), age(a) {}
};
// 仿函数 less，用于比较 Person 类对象的年龄
struct LessByAge {
bool operator()(const Person& p1, const Person& p2) const {
return p1.age < p2.age;
}
};
// 仿函数 greater，用于比较 Person 类对象的年龄
struct GreaterByAge {
bool operator()(const Person& p1, const Person& p2) const {
return p1.age > p2.age;
}
};
int main() {
vector<Person> people = {
Person("Alice", 25),
Person("Bob", 22),
Person("Charlie", 30),
Person("David", 28)
};
// 使用 LessByAge 仿函数进行升序排序（按年龄）
sort(people.begin(), people.end(), LessByAge());
cout << "People sorted by age in ascending order:" << endl;
for (const auto& person : people) {
cout << "Name: " << person.name << ", Age: " << person.age << endl;
}
// 使用 GreaterByAge 仿函数进行降序排序（按年龄）
sort(people.begin(), people.end(), GreaterByAge());
cout << "People sorted by age in descending order:" << endl;
for (const auto& person : people) {
cout << "Name: " << person.name << ", Age: " << person.age << endl;
}
return 0;
}其运行结果为：
② 当一个类支持比较大小但其行为与我预期的不相符，就可以写一个仿函数来控制比较逻辑。如下代码所示：
// 自定义的类，支持比较大小，但比较逻辑可能不符合预期
class Number {
public:
int value;
Number(int val) : value(val) {}
// 原有的比较运算符，按照值的大小进行比较
bool operator<(const Number& other) const {
return value < other.value;
}
};
// 仿函数，改变比较逻辑，根据值的绝对值进行比较
struct CompareByAbsoluteValue {
bool operator()(const Number& num1, const Number& num2) const {
return abs(num1.value) < abs(num2.value);
}
};
void test02()
{
vector<Number> numbers = { Number(-5), Number(3), Number(-2), Number(8), Number(-1) };
// 按照原有的比较逻辑进行排序（升序）
sort(numbers.begin(), numbers.end());
cout << "Sorted by original comparison operator (ascending by value): ";
for (const auto& num : numbers) {
cout << num.value << " ";
}
cout << endl;
// 使用仿函数按照绝对值进行排序（升序）
sort(numbers.begin(), numbers.end(), CompareByAbsoluteValue());
cout << "Sorted by custom comparison functor (ascending by absolute value): ";
for (const auto& num : numbers) {
cout << num.value << " ";
}
cout << endl;
}
int main() {
test02();
return 0;
}（五）区分仿函数加括号与不加括号的情况
在使用sort进行比较时控制比较大小的逻辑时要加括号（），区分一下加括号与不加括号：
sort(dq1.begin(),dq1.end(),less<int>())
priority_queue<int, vector<int>, less<int>> q;区别：一个是函数的参数（传对象，本质是传匿名对象），一个是类模板的参数（是一个类型）。
以上内容仅供分享，若有错误，请多指正。