Stack 和 Queue
介绍
LIFO stack（后进先出栈）：栈是一种容器适配器，专门设计用于后进先出的后进先出环境，在这种环境中，元素只从容器的一端插入和提取。栈是作为容器适配器实现的，这些适配器是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素从特定容器的"后面"（即堆栈的顶部）被推入/弹出。底层容器可以是任何标准容器类模板或其他特定设计的容器类。容器应支持以下操作：empty、size、back、push_back、pop_back。标准容器类vector、deque和list满足这些要求。默认情况下，如果没有为特定堆栈类实例化指定容器类，则使用标准容器队列。
FIFO queue（先进先出队列）：队列是一种容器适配器，专门设计用于在FIFO上下文中操作（先进先出），其中将元素插入容器的一端并从另一端提取。队列是作为容器适配器实现的，容器适配器是使用特定容器类的封装对象作为其底层容器的类，提供一组特定的成员函数来访问其元素。元素被推入特定容器的"后面"，并从其"前面"弹出。底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操作：empty、size、front、back、push_back、pop_front。标准容器类deque和list满足这些要求。默认情况下，如果没有为特定队列类实例化指定容器类，则使用标准容器队列。
根据官方介绍可知，LIFO栈和FIFO队列分别是专为后进先出和先进先出环境设计的容器适配器，它们利用特定容器类作为底层容器，并提供特定的成员函数来访问元素，这些底层容器需支持一系列基本操作，且标准容器类如vector、deque和list可用于满足这些要求。
C语言实现栈和队列：栈和队列
使用
stack：
| 函数名称 | 接口说明 |
|---|---|
| stack() | 构造空的栈 |
| empty() | 检测stack是否为空 |
| size() | 返回stack中元素的个数 |
| top() | 返回栈顶元素的引用 |
| push() | 将元素压入stack中 |
| pop() | 将stack中尾部的元素弹出 |
queue：
| 函数名称 | 接口说明 |
|---|---|
| queue() | 构造空的队列 |
| empty() | 检测queue是否为空 |
| size() | 返回queue中元素的个数 |
| front() | 返回队列头部的引用 |
| back() | 返回队列尾部的引用 |
| push() | 将元素压入queue中 |
| pop() | 将queue中头部的元素弹出 |
OJ练习
下面我们通过几道例题来演示栈和队列的使用：
1、最小栈：设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
实现 MinStack 类:
MinStack():初始化堆栈对象。void push(int val):将元素val推入堆栈。void pop():删除堆栈顶部的元素。int top(): 获取堆栈顶部的元素。int getMin():获取堆栈中的最小元素。
提示：
-2^31 <= val <= 2^31 - 1pop、top和getMin操作总是在 非空栈 上调用push,pop,top, andgetMin最多被调用3 * 10^4次
解析：
代码演示：
cpp
class MinStack {
public:
void push(int val) {
_st.push(val);
if(_minst.empty() || val <= _minst.top())
_minst.push(val);
}
void pop()
{
if(_minst.top() == _st.top())
_minst.pop();
_st.pop();
}
int top() {
return _st.top();
}
int getMin() {
return _minst.top();
}
private:
std::stack<int> _st;
std::stack<int> _minst;
};2、栈的压入、弹出序列
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。
-
0<=pushV.length == popV.length <=1000。
-
-1000<=pushV[i]<=1000。
-
pushV 的所有数字均不相同。
思路讲解：
这道题本质上就是模拟栈的压入和弹出过程。首先定义一个新栈用来模仿入栈过程，另一边使用popi来访问弹出过程的元素顺序，当入栈的数据等于出栈数据时，开始删除新栈的数据，直到入栈数据不等于出栈数据时，继续入栈过程，直到所有数据全部入栈，最后如果栈为空，说明是该压栈序列的弹出序列，否则不是。
代码演示：
cpp
class Solution {
public:
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
* @param pushV int整型vector
* @param popV int整型vector
* @return bool布尔型
*/
bool IsPopOrder(vector<int>& pushV, vector<int>& popV) {
stack<int> st;
int popi = 0;
for(auto& e : pushV)
{
st.push(e);
while(!st.empty() && st.top() == popV[popi])
{
st.pop();
popi++;
}
}
return st.empty();
}
};3、用栈实现队列
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x)将元素 x 推到队列的末尾int pop()从队列的开头移除并返回元素int peek()返回队列开头的元素boolean empty()如果队列为空，返回true；否则，返回false
说明：
- 你只能使用标准的栈操作 ------ 也就是只有
push to top,peek/pop from top,size, 和is empty操作是合法的。 - 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
代码演示：这里在之前栈和队列章节讲过，这里不再多说。
cpp
class MyQueue {
public:
void push(int x) {
st1.push(x);
}
int pop() {
while(!st1.empty())
{
st2.push(st1.top());
st1.pop();
}
int val = st2.top();
st2.pop();
while(!st2.empty())
{
st1.push(st2.top());
st2.pop();
}
return val;
}
int peek() {
while(!st1.empty())
{
st2.push(st1.top());
st1.pop();
}
auto val = st2.top();
while(!st2.empty())
{
st1.push(st2.top());
st2.pop();
}
return val;
}
bool empty() {
return st1.empty();
}
private:
std::stack<int> st1;
std::stack<int> st2;
};容器适配器
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结)，该种模式是将一个类的接口转换成客户希望的另外一个接口。
虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，比如：
priority_queue(优先级队列)
介绍
- 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素
中最大的。 - 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶
部的元素)。 - 优先级队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的"尾部"弹出，其称为优先队列的顶部。
- 底层容器可以是任何标准容器类模板，也可以是其他特定设计的容器类。容器应该可以通过
随机访问迭代器访问，并支持以下操作：
empty()：检测容器是否为空
size()：返回容器中有效元素个数
front()：返回容器中第一个元素的引用
push_back()：在容器尾部插入元素
pop_back()：删除容器尾部元素 - 标准容器类vector和deque满足这些需求。默认情况下，如果没有为特定的priority_queue
类实例化指定容器类，则使用vector。 - 需要支持随机访问迭代器，以便始终在内部保持堆结构。容器适配器通过在需要时自动调用
算法函数make_heap、push_heap和pop_heap来自动完成此操作。
使用
优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用堆算法将vector中的元素构造成堆结构，因此priority_queue就是堆，所有需要用到堆的位置都可以考虑使用priority_queue。注意：默认情况下priority_queue是大堆。
| 函数名称 | 接口说明 |
|---|---|
| priority_queue() / priority_queue(first, last) | 构造一个空/迭代器区间的优先级队列 |
| empty() | 检测优先级队列是否为空，是则返回true，否则返回false。 |
| top() | 返回优先级队列中最大(最小元素)，即堆顶元素。 |
| push(x) | 在优先级队列中插入元素x |
| pop() | 删除优先级队列中最大(最小)元素，即堆顶元素。 |
优先级队列的模拟实现
cpp
#pragma once
#include<vector>
#include<list>
#include<queue>
namespace zy
{
template<class T>
class less
{
public:
bool operator()(const T& x, const T& y)
{
return x < y;
}
};
template<class T>
class greater
{
public:
bool operator()(const T& x, const T& y)
{
return x > y;
}
};
template<class T, class Container = vector<int>, class Compare = less<T>>
class priority_queue
{
public:
// 创造空的优先级队列
priority_queue() : _con() {}
template<class Iterator>
priority_queue(Iterator first, Iterator last)
: _con(first, last)
{
// 将_con中的元素调整成堆的结构
int count = _con.size();
int root = ((count - 2) >> 1);
for (; root >= 0; root--)
AdjustDown(root);
}
void push(const T& x)
{
_con.push_back(x);
AdjustUP(_con.size() - 1);
}
void pop()
{
if (empty())
return;
swap(_con.front(), _con.back());
_con.pop_back();
AdjustDown(0);
}
const T& top() const
{
return _con.front();
}
size_t size() const
{
return _con.size();
}
bool empty() const
{
return _con.empty();
}
private:
// 向上调整
void AdjustUP(int child)
{
int parent = ((child - 1) >> 1);
while (child)
{
if (Compare()(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
child = parent;
parent = ((child - 1) >> 1);
}
else
{
return;
}
}
}
// 向下调整
void AdjustDown(int parent)
{
size_t child = parent * 2 + 1;
while (child < _con.size())
{
// 找以parent为根的较大的孩子
if (child + 1 < _con.size() && Compare()(_con[child], _con[child + 1]))
child += 1;
// 检测双亲是否满足情况
if (Compare()(_con[parent], _con[child]))
{
swap(_con[child], _con[parent]);
parent = child;
child = parent * 2 + 1;
}
else
return;
}
}
private:
Container _con;
};
void TestQueuePriority()
{
zy::priority_queue<int> q1;
q1.push(5);
q1.push(1);
q1.push(4);
q1.push(2);
q1.push(3);
q1.push(6);
cout << q1.top() << endl;
q1.pop();
q1.pop();
cout << q1.top() << endl;
vector<int> v{ 5,1,4,2,3,6 };
zy::priority_queue<int, vector<int>, zy::greater<int>> q2(v.begin(), v.end());
cout << q2.top() << endl;
q2.pop();
q2.pop();
cout << q2.top() << endl;
}
}OJ练习
给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
思路：本题比较简单，我们只需要删除前 k-1 个最大的元素，然后返回栈顶元素即可。
代码演示：
cpp
class Solution {
public:
int findKthLargest(vector<int>& nums, int k)
{
priority_queue<int> pq(nums.begin(), nums.end());
for (int i = 0; i < k-1; ++i) {
pq.pop();
}
return pq.top();
}
};deque(双端队列)【了解即可】
deque(双端队列):是一种双开口的"连续"空间的数据结构，双开口的含义是可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较空间利用率高。
deque的底层结构并不是真正连续的空间，而是由一段段连续的小空间拼接而成，本质上类似于动态的二维数组，其底层结构如下图所示：
双端队列底层是一段假象的连续空间，实际上是分段连续的，为了维护其"整体连续"以及随机访问的家乡，重担落在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图：
deque的缺陷
与vector相比，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不需要搬移大量的元素，因此其效率是必vector高的。
与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。
但是，deque有一个致命缺陷：不适合遍历，因为在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，而序列式场景中，可能需要经常遍历，因此在实
际中，需要线性结构时，大多数情况下优先考虑vector和list，deque的应用并不多，而目前能看到的一个应用就是，STL用其作为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的优点，而完美的避开了其缺陷。