stack/queue/priority_queue类

噜啦噜啦嘞好

墨衍会员 · AI 创作全网分发码龄3年

关注

原创 2025-03-15 10:28:23 1.1k 阅读 AI 写同款· GEO 优化 ›

stack、queue、priority_queue、deque STL 阅读详情

deque类

为什么实现stack和queue的类模板需要容器呢？

deque是什么呢？

deque容器的优点：

deque的缺点：

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

deque类

我们发现stack/queue在STL标准库中的底层结构都有deque容器。

为什么实现stack和queue的类模板需要容器呢？

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

deque是什么呢？

deque是STL的一种容器，可以双向进出（即可以在头尾两端进行插入、删除操作），时间复杂度为O（1）。deque类似于一个动态的二维数组。

deque容器的优点：

我们知道vector的优点是可以根据下标进行随机访问，list的优点是可以高效的在任意位置插入删除。而deque则是结合了它们两个的优点，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高。

deque的缺点：

不适合遍历，在遍历时，deque的迭代器要频繁的去检测其是否移动到某段小空间的边界，导致效率低下，所以在实际中，需要线性结构时，大多数情况下优先考虑list、vector。

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

stack只要具有push_back()和pop_back()操作的线性结构，都可以作为stack的底层容器，比如list、vector。queue只要具有push_back()和pop_front()操作的线性结构，都可以作为queue的底层容器，比如list。但为什么STL中对stack和queue默认底层容器是deque呢？

1.stack和queue不需要遍历（因此stack和queue没有迭代器），只需要在头尾操作就可以。

2.deque效率高。

完美避开了deque的缺陷。

stack类

stack的介绍

1.在数据结构中我们学习过stack（栈），我们知道栈的特点是先进后出的。

2.该底层容器至少支持以下操作：

push ：入栈

pop：出栈

empty：检测栈是否为空

size：返回队列中有效个数

top：返回栈顶元素

3.STL标准库中stack的底层结构

stack的模拟实现

#include<deque>
namespace slm
{
	template <class T,class Container=std::deque<T>>
	class stack
	{
	public:
		void push(const T& x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_back();
		}
		const T& top()
		{
			return _con.back();
		}
		size_t size() const
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

queue类

queue的介绍

1.在数据结构中我们了解了queue（队列）的特点是先进先出（即在队尾入数据在队头出数据）。

2.该底层容器应至少支持以下操作:
empty：检测队列是否为空
size：返回队列中有效元素的个数
front：返回队头元素的引用
back：返回队尾元素的引用
push_back：在队列尾部入队列
pop_front：在队列头部出队列

3.STL中queue的底层结构

queue的模拟实现

#include<deque>
namespace slm
{
	template<class T,class Container=std::deque<T>>
	class queue
	{
	public:
		void push(const T&x)
		{
			_con.push_back(x);
		}
		void pop()
		{
			_con.pop_front();
		}
		const T& front()
		{
			return _con.front();
		}
		const T& back()
		{
			return _con.back();
		}
		size_t size()const
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

priority_queue类

priority_queue的介绍

1.优先级队列也是一种适配器，但是在STL中默认使用vector作为priority_queue的底层容器。

2. 优先级队列不同于queue的是，优先级队列根据严格的弱排序标准，它的第一个元素总是最大的。

3.优先级队列实际上就是堆。在vector上使用了堆算法将vector中元素构造成堆的结构。默认情况下优先级队列是大堆（堆顶是最大的数）。

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

priority_queue的模拟实现

#include<vector>
namespace slm
{
	//比较大小
	template<class T>//越往后数越小
	class less
	{
	public: 
		bool operator()(const T& x, const T& y)//仿函数
		{
			return x < y;
		}
	};
	template<class T>
	class greater//越往后数越大
	{
		bool operator()(const T& x, const T& y)//仿函数
		{
			return x > y;
		}
	};
	template<class T,class Container=std::vector<T>,class compare=less<T>>//大堆
	class priority_queue
	{
	public:
		void adjust_up(size_t child)//向上调整
		{
			size_t parent = (child - 1) / 2;
			compare com;
			while (child > 0)
			{
				if (com(_con[parent], _con[child]))
				{
					std::swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void push(const T& x)
		{
			_con.push_back(x);
			adjust_up(_con.size() - 1);
		}
		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[parent], _con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		void pop()
		{
			std::swap(_con.front(), _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}
		const T& top()
		{
			return _con.front();
		}
		size_t size()const
		{
			return _con.size();
		}
		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}