双端队列（deque）与优先队列（priority_queue）

一.双端队列——deque

在上一章stack、queue的模拟实现中，我们使用的是vector 来作为底层容器。但是，在标准库中，都是使用deque来作为底层容器的，那么deque究竟为何能受到青睐呢？

1.deque的优点与缺点

deque对标的是vector与list，我们可以认为deque是vector与list的结合并且取其精华去其糟粕。

vector的优缺点

1. 尾插尾删效率高，头插头删效率低
2. 支持随机访问
3. 扩容代价高

list的优缺点

1. 头删头插效率高
2. 尾插尾删效率高
3. 不支持随机访问
4. 不需要扩容

deque的优点

1. 头删头插效率高
2. 尾插尾删效率高
3. 支持随机访问
4. 扩容代价低（相比vector）

• deque看起来挺不错的，完美的继承了vector与list的优点。但是，既然deque这么优秀，为什么我们又好像没怎么学习过它呢？答案是，它也有它的缺点。

deque的缺点

1. 中间插入或删除效率低
2. 没有vector与list的优点那么极致

deque的产生就像是什么呢？就例如，我继承了爱因斯坦的高智商，又继承了泰森的力量，但是继承的过程有一些损耗，所以我既没有爱因斯坦极致的智商，又没有泰森极致的力量，我只是个普通人。所以我们说，deque相当于vector与list的结合产品。

deque看似很中庸，实际用处不大，但是，作为stack与queue的底层容器却又刚好合适，因为栈和队列的性质完美的避开了deque的缺点，只用到了deque的优点——栈和队列只对头部或者尾部进行操作。

2.deque的原理

对于deque，我们只需要大致认识它的底层结构即可。

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

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

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

那deque是如何借助其迭代器维护其假想连续的结构呢？

对于deque我们只需做到了解就可以。

二.优先队列——priority_queue

1.什么是优先队列？

priority_queue与stack和queue相同，都是一种容器适配器。默认使用vector作为其底层存储数据的容器，在vector上又使用了堆算法将vector中元素构造成堆的结构，因此priority_queue就是堆。

优先级队列允许你以任意顺序插入元素，并且每次弹出的元素是当前优先级最高（及最大或最小）的元素。在priority_queue中，元素的插入顺序不影响元素的优先级，而是根据其优先级属性进行排序。

2.优先队列的基本使用

• 包含头文件 < queue >

#include 

• 定义一个priority_queue对象

priority_queue<int> pq;

• 向队列中插入一个元素

pq.push(1);
pq.push(5);
pq.push(2);

• 从队列中弹出一个元素（该元素为队列内优先级最高的元素）

pq.pop();

• 返回队列中优先级最高的元素（及堆顶的元素）

cout << pq.top() << endl;

• 返回队列中的元素数量

cout << pq.size() << endl;

• 判断队列是否为空

//empty()
if (pq.empty())
{
	cout << "Queue is empty" << endl;
}
else
{
	cout << "Queue is not empty" << endl;
}

特别注意

优先级队列默认是建大堆，也就是元素的值越大，优先级越高。我们可以通过一个传递模板参数来控制优先级的判别。所以，优先级队列在设计的时候用到了3个模板参数，而我们上一章所学习的stack与queue则是2个模板参数，如图：

	// 默认情况下，创建的是大堆，其底层按照小于号比较
	priority_queue<int> pq1;
	// 如果要创建小堆，将第三个模板参数换成greater比较方式
	// 记得包含greater算法的头文件——#include 
	priority_queue<int, vector<int>, greater<int>> pq2;

第三个模板参数仅仅只有比较大小的作用，我们也可以自己实现这样一个模板类来传递。像图中Compare这样的类所创建的对象，我们通常称它为——仿函数。因为该类的对象可以像函数一样使用。

3.什么是仿函数？

仿函数（functor）是一种行为类似于函数的对象，它可以像函数一样被调用。在C++中，仿函数通常是一个类，它重载了函数调用运算符operator()，并且可以像函数一样使用。

仿函数可以被用来封装一些操作或算法，它们可以被传递给其他函数或算法作为参数，或者作为返回值返回给调用者。由于仿函数是一个对象，因此可以在调用它们的过程中保持状态信息，这使得它们可以非常灵活地实现不同的行为。

例如上述的优先级队列又或是库中的sort函数，sort()函数可以接受一个仿函数对象作为第三个参数，这个仿函数对象将被用来比较两个元素的大小关系，这样我们就可以灵活的运用sort函数排序数列为升序或者降序了。

关于仿函数，我们点到为止。

4.优先队列的模拟实现

关于堆的结构前面已经详细讲解过点我

#include 
#include 
using namespace std;

namespace dianxia
{
	// 小于
	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;
		}
	};

	// priority_queue类
	template<class T, class Container = vector<T>,class Compare=less<T>>
	class priority_queue
	{
		// 比较的对象
		Compare com;

		// 向上调整
		void adjust_up(int child)
		{
			size_t  parent = (child - 1) / 2;

			while (child > 0)
			{
				if (com(_con[parent] ,_con[child]))
				{
					swap(_con[parent], _con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}

		// 向下调整
		void adjust_down(int parent)
		{
			int child = parent * 2 + 1;
			while (child < _con.size())
			{
				// 确保child是两个孩子中大/小的那一个
				if (child + 1 < _con.size() && com(_con[child], _con[child + 1]))
				{
					++child;
				}

				if (com(_con[parent], _con[child]))
				{
					swap(_con[parent], _con[child]);
						parent = child;
						child = parent * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
	public:

		void push(const T& data)
		{
			_con.push_back(data);
			adjust_up(_con.size()-1);
		}

		void pop()
		{
			// 堆顶元素与堆尾元素互换
			swap(_con[0],_con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}

		const T& top()
		{
			return _con[0];
		}

		size_t size()
		{
			return _con.size();
		}

		bool empty()
		{
			return _con.empty();
		}
	private:
		Container _con;
	};
}

---

本文到此结束，码文不易，还请多多支持哦！！！