深入解析C++ STL中的stack与queue（含模拟实现）

于 2025-08-18 16:51:26 发布
阅读量618 收藏 16
点赞数 10
CC 4.0 BY-SA版权
分类专栏： c++ 文章标签： 面试 开发语言 c++ c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79440910/article/details/150486182

目录

1. stack的介绍和使用

1.1 stack的介绍

1.2 stack的使用

stack和queue是C++标准库中的容器适配器，它们本身不提供迭代器支持；

1.3 stack的模拟实现

2. queue的介绍和使用

2.1 queue的介绍

2.2 queue的使用接口

2.3 queue的模拟实现

3. priority_queue的介绍和使用

3.1 priority_queue的介绍

3.2 priority_queue的使用

3.4 priority_queue的模拟实现

（1）比较逻辑的实现

（2）向上、向下调整算法接口

（3）整体实现

4. 容器适配器

4.1 什么是适配器

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

1. stack的介绍和使用

1.1 stack的介绍

1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。

2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。

3. stack的底层容器可以是任何标准的容器类模板或者一些其他特定的容器类，这些容器类应该支持以下 操作： empty：判空操作 ，back：获取尾部元素操作， push_back：尾部插入元素操作， pop_back：尾部删除元素操作

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

deque的原理介绍

  1.deque(双端队列)：是一种双开口的"连续"空间的数据结构，双开口的含义是：可以在头尾两端进行插入和 删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。

  deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维 数组。双端队列底层是一段假象的连续空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落 在了deque的迭代器身上，因此deque的迭代器设计就比较复杂，

  2.deque的缺陷

  与vector比较，deque的优势是：头部插入和删除时，不需要搬移元素，效率特别高，而且在扩容时，也不 需要搬移大量的元素，因此其效率是必vector高的。 与list比较，其底层是连续空间，空间利用率比较高，不需要存储额外字段。

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

1.2 stack的使用

stack和queue是C++标准库中的容器适配器，它们本身不提供迭代器支持；

1.3 stack的模拟实现

从栈的接口中可以看出，栈实际是一种特殊的vector，因此使用vector完全可以模拟实现stack。

#include<vector>
 
namespace bite
{
 template<class T>
 class stack
 {
 public:
 stack() {}
 void push(const T& x) {_c.push_back(x);}
 void pop() {_c.pop_back();}
 T& top() {return _c.back();}
 const T& top()const {return _c.back();}
 size_t size()const {return _c.size();}
 bool empty()const {return _c.empty();}
 private:
 std::vector<T> _c;
}
}

但我们还是要仿照底层容器适配器的形式，做一次比较完整的模拟：

#pragma once
#include<iostream>
#include <deque>
using namespace std;
template<class T,class Container = deque<T>>
class Stack
{
public:
	void push(const T& x)
	{
		_container.push_back(x);
	}
	void pop()
	{
		_container.pop_back();
	}
	int size()
	{
		return _container.size();
	}
	const T& top()
	{
		return _container.back();

	}
	bool empty()
	{
		return _container.empty();

	}
private:
	Container _container;
};

  stack的实现非常简单，因为我们用了容器适配器，将底层的操作都交给了stl容器，这些容器都已经做足了封装，我们就不用关心那么多了，像图中代码，我们默认采用deque容器来存储数据，当然也可以显示传入vector、list都行；

  不用写构造、拷贝构造、析构等等，因为底层只有一个容器，我们只需要调用容器的构造、析构等即可，不用自己额外去写；

2. queue的介绍和使用

2.1 queue的介绍

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

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

3. 底层容器可以是标准容器类模板之一，也可以是其他专门设计的容器类。该底层容器应至少支持以下操 作: empty：检测队列是否为空 ，size：返回队列中有效元素的个数， front：返回队头元素的引用 ，back：返回队尾元素的引用 ，push_back：在队列尾部入队列， pop_front：在队列头部出队列；

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

2.2 queue的使用接口

2.3 queue的模拟实现

template<class T, class Container = deque<T>>
class Queue
{
public:
	void push(const T& x)
	{
		_container.push_back(x);
	}
	void pop()
	{
		_container.pop_front();
	}
	int size()
	{
		return _container.size();
	}
	const T& front()
	{
		return _container.front();

	}
	const T& back()
	{
		return _container.back();
	}
	bool empty()
	{
		return _container.empty();
	}
private:
	Container _container;
};

3. priority_queue的介绍和使用

3.1 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来自动完成此操作。

注意：stack和queue默认采用deque，而priority_queue默认采用vector，原因如下：

  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的优点，而完美的避开了其缺陷。

  优先队列则默认使用vector作为底层容器，因为它需要支持随机访问迭代器，以便高效实现堆算法（如makeheap、pushheap和popheap）。vector的连续内存布局使得堆操作更加高效，而deque虽然支持随机访问，但其内存分布不如vector紧凑，堆操作（遍历）时可能需要额外的开销。说白了，优先队列在构建堆的时候会遍历容器，所以不适合用deque；

3.2 priority_queue的使用

  优先级队列默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成 堆的结构，因此priority_queue就是堆，所有需要用到堆的位置，都可以考虑使用priority_queue。注意： 默认情况下priority_queue是大堆。

【注意】 1. 默认情况下，priority_queue是大堆。

第三个模板参数是仿函数（functor），用于自定义元素的比较规则，从而控制队列的排序方式；

默认情况下，优先队列使用std::less作为比较规则，其底层按照小于号比较，形成大顶堆（降序排列）。通过第三个模板参数，可以传入自定义的比较逻辑，例如使用std::greater实现小顶堆（升序排列），其底层按照大于号比较；

顺带一提，在不同容器中，less和greater的行为表现有所不同：

  • priority_queue：

    • greater使堆顶元素为最小值（小顶堆）
    • less使堆顶元素为最大值（大顶堆）

  • sort、multiset、vector等：

    • less实现从小到大排序
    • greater实现从大到小排序

2. 如果在priority_queue中放自定义类型的数据，用户需要在自定义类型中提供> 或者< 的重载。

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;
}

3.4 priority_queue的模拟实现

（1）比较逻辑的实现

  

template<class T>
class myless
{
public:
	bool operator()(const T& a, const T& b)
	{
		return a < b;
	}
};
template<class T>
class mygreater
{
public:
	bool operator()(const T& a, const T& b)
	{
		return a > b;
	}
};

  在堆操作中，会涉及到元素的比较大小，我们通过函数模版修饰的仿函数对象来实现了各种类型的比较大小，其中，myless依赖于小于，mygreater依赖大于实现，但是对于自定义类型，要想也使用这两个仿函数对象来比较大小，必须在类中重载>和<运算符，这和我们上面说的对应上了！

  在堆操作中离不开向上调整和向下调整算法，接下来就实现它们：

（2）向上、向下调整算法接口
void adjustUP(int child)
{
	func  comp;
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (comp(_container[parent], _container[child]))
		{
			swap(_container[parent], _container[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
void adjustDown(int parent)
{
	func  comp;

	int child = parent * 2 + 1;
	while (child < _container.size())
	{
		if (child + 1 < _container.size() && func(_container[child], _container[child+1]))
		{
			child++;
		}
		if (comp(_container[parent], _container[child]))
		{
			swap(_container[parent], _container[child]);
		    parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

这两个算法接口在我前面整理数据结构专栏中，对“堆”的模拟实现中有讲，大家可以看一下：深入解析二叉树（包含堆结构）数据结构-CSDN博客

区别是在比较元素上需要用我们定义的仿函数对象，可能比较绕；

（3）整体实现

有了前面的辅助接口，接下来实现优先队列就很简单了，首先，它也是一个容器适配器，默认采用vector存储，且第三个模版参数代表比较逻辑，默认采用less，也就是建大堆；其余接口的实现思路基本和实现堆结构时一样。深入解析二叉树（包含堆结构）数据结构-CSDN博客

  注意：当我们想要建小堆，就需要传入mygreater了，如果是自定义类型，还需要重载比较运算符；这些和stl的优先队列保持一致！

namespace test
{
	template<class T>
	class myless
	{
	public:
		bool operator()(const T& a, const T& b)
		{
			return a < b;
		}
	};
	template<class T>
	class mygreater
	{
	public:
		bool operator()(const T& a, const T& b)
		{
			return a > b;
		}
	};
	template<class T,class Container = vector<T>,class func = myless<T>>
	class Priority_queue
	{
	public:
		Priority_queue() = default;
		template<class Inputinitial>
		Priority_queue(Inputinitial first, Inputinitial last)
		{
			while (first != last)
			{
				_container.push_back(*first);
				first++;
			}
			for (int i = (_container.size() - 1 - 1) / 2; i >= 0; i--)
			{
				adjustDown(i);
			}
		}
		void push(const T& x)
		{
			_container.push_back(x);
			adjustUP(_container.size() - 1);
		}
		void pop()
		{
			swap(_container[0], _container[_container.size() - 1]);
			_container.pop_back();
			adjustDown(0);
		}
		const T& top()
		{
			return _container[0];
		}
		int size()
		{
			return _container.size();
		}
		bool empty()
		{
			return _container.empty();
		}
	private:
		void adjustUP(int child)
		{
			func  comp;
			int parent = (child - 1) / 2;
			while (child > 0)
			{
				if (comp(_container[parent], _container[child]))
				{
					swap(_container[parent], _container[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjustDown(int parent)
		{
			func  comp;

			int child = parent * 2 + 1;
			while (child < _container.size())
			{
				if (child + 1 < _container.size() && func(_container[child], _container[child+1]))
				{
					child++;
				}
				if (comp(_container[parent], _container[child]))
				{
					swap(_container[parent], _container[child]);
				    parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
	private:
		Container _container;
	};
}

4. 容器适配器

4.1 什么是适配器

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

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

  虽然stack和queue中也可以存放元素，但在STL中并没有将其划分在容器的行列，而是将其称为容器适配器，这是因为stack和队列只是对其他容器的接口进行了包装，STL中stack和queue默认使用deque，比如：

C++必修：STL之stack与queue的使用与实现
Bettysweetyaaa的博客
08-11 1373
本文涵盖栈、队列及逆波兰表达式知识。介绍其概念、容器适配器、使用方法、模拟实现，还有中缀转后缀及计算规则。丰富内容助您深入理解数据结构，快来探索！
c＋＋STL中stack，queue使用方法和模拟实现，及适配器模式编程
qq_58761784的博客
08-10 1479
1.1 stack的介绍栈是计算机中一个重要的数据结构，因其先进先出的特性，可以解决许多结构上的问题，进行栈的学习，了解它的底层是很有必要的。1. stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。2. stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。
【STL】 stack 与 queue（C++）
2301_80362419的博客
10-18 1367
STL stack queue priority_queue 容器适配器 dequeue
【C++】STL——stack和queue
2301_77112794的博客
10-10 1081
本文主要讲了STL的容器适配器stack和queue
C++STL之stack和queue
What_hope的博客
08-20 252
在我们使用C语言来实现stack---栈和queue---队列时，其底层使用了数组和链表来存放数据，而在C++的stack和queue类中，通过模版实现了容器适配器，在创建时，我们可以用尖括号中第二个类型决定stack和queue的底层容器，如果不写，默认为deque。与vector和list相比，deque在头插和尾插上面的效率要更优，下标随机访问也不错，但相比vector略逊一筹，中间插入效率很低，要挪动数据，是O(n)
c++STL——stack、queue、priority_queue的模拟实现
2301_79705195的博客
04-22 1186
c++STL——stack、queue、priority_queue的模拟实现
【C++】STL库_stack_queue 的模拟实现
weixin_45423515的博客
03-30 1255
栈（Stack）、队列（Queue）是C++ STL中的经典容器适配器容器适配器特性（栈和队列前面C语言写过，这里直接贴C++代码）
【STL】stack和queue的实现原理
qq_43142509的博客
10-27 1101
文章目录
C++ stl容器stack，queue，priority_queue的底层模拟实现
2301_79698419的博客
04-21 1058
stack，queue，priority_queue的底层模拟实现
C++ STL容器stack和queue详解
09-01
C++ STL（Standard Template Library，标准模板库）提供了两种特殊的线性容器：stack（栈）和queue（队列），它们都是基于顺序容器（如vector或deque）实现的抽象数据类型，用于实现特定的数据操作逻辑。 **1. ...
C++STL的stack和queue(超详解)
庖丁解牛，恢恢乎游刃有余
12-13 1731
栈和队列这一块其实有数据结构的基础，学起来非常简单。
C++ STL——栈和队列（stack & queue）
希望自己从编程小白变成大佬
12-19 2081
2.1 queue的介绍queue的文档介绍根据queue的文档介绍可以知道,队列是一种容器适配器，专门设计用于在 FIFO 上下文（先进先出）中运行，其中元素插入容器的一端并从另一端提取。队列作为容器适配器实现，容器适配器是使用特定容器类的封装对象作为其基础容器的类，提供一组特定的成员函数来访问其元素。元素被推入特定容器的“背面”(即队尾)，并从其“正面”(即队头)弹出。基础容器可以是标准容器类模板之一，也可以是其他一些专门设计的容器类。emptysize。
力扣面试150(58/150)
2403_88913721的博客
08-17 321
本文介绍了一种翻转二叉树的递归解法。通过后序遍历的方式，先递归处理左右子树，再交换当前节点的左右孩子。算法时间复杂度为O(n)，空间复杂度为O(h)，其中h为树的高度。代码简洁明了，适用于任意结构的二叉树翻转。
【牛客刷题】BM63 跳台阶：三种解法深度解析（递归/DP动态规划/记忆化搜索）
最新发布
字节卷动
08-17 46
本文介绍了青蛙跳台阶问题的四种解法：递归法、动态规划、记忆化搜索和优化动态规划。该问题本质是斐波那契数列的变形，其中f(n)=f(n-1)+f(n-2)。递归法虽然直观但效率最低（时间复杂度O(2ⁿ)），动态规划（O(n)）和记忆化搜索（O(n)）通过存储中间结果提高效率，优化DP则进一步将空间复杂度降至O(1)。当n=40时，优化DP仅需40次计算即可完成，而递归法需要约1万亿次计算。文章详细分析了每种解法的实现原理、性能差异和适用场景，并提供了完整的Java代码实现。
Java面试宝典：JVM性能优化
搬砖的小熊猫的博客
08-14 156
方法内联是JVM性能优化的基石。它通过消除调用开销和开启后续优化，对性能提升至关重要。开发者通过编写结构清晰、方法小巧、确定性高的代码，可以显著提高方法被成功内联的概率，从而充分利用JVM的优化能力。
【KO】Android 网络相关面试题
abbiz的博客
08-13 756
回答网络问题时，务必结合 Android 实际场景（如 OkHttp、Glide、系统 API ），体现你对“Android 网络栈”的理解。聊 HTTPS 时，提证书锁定和自签名证书处理（面试官关注安全实践 ）。聊 TCP/UDP 时，结合OkHttp 连接池或WebRTC 实时通信（体现场景化思考 ）。这样的回答，既覆盖底层原理，又关联 Android 开发实战，更符合中高级面试对“知识深度 + 业务落地”的考察要求~
LeetCode 面试经典 150_数组/字符串_最后一个单词的长度（19_58_C++_简单）(反向遍历)
huayimenghan的博客
08-14 587
LeetCode 面试经典 150_数组/字符串_最后一个单词的长度（19_58_C++_简单） 题目描述： 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个单词的长度。 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
Redis面试精讲 Day 22：Redis布隆过滤器应用场景
在未来等你的专栏
08-15 964
布隆过滤器（Bloom Filter）是一种基于概率的数据结构，用于快速判断一个元素是否可能存在于集合中或一定不存在。它由 Burton Howard Bloom 在1970年提出，核心思想是使用多个哈希函数将元素映射到位数组中的多个位置。如果所有对应位都为1 → 元素可能存在如果任一位为0 → 元素一定不存在空间效率极高：相比HashSet，内存占用可降低90%以上查询速度快：O(k)，k为哈希函数个数存在误判率（False Positive）：可能将不存在的元素误判为存在（但不会漏判）
面试实战 问题三十二 Java中创建对象的几种方式
Rockandrollman的博客
08-14 388
面试实战 问题三十二 Java中创建对象的几种方式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值