C++优先级队列PriorityQueue模拟实现

C++优先级队列PriorityQueue模拟实现

1.引言

​

我们都知道队列是一种**FIFO(先进先出)**性质的配接器。

那么在生活中总会看到排队的情况出现。这已经就类似于队列的意义，提前排队的人提前出去。但实际生活中总会有人享有更高的优先级，譬如：军人优先、孕妇优先等。享有特殊性质的人总会有优先特权，这就是优先级队列（PriorityQueue）创建的意义。

2. 认识与创建

优先级队列是一种特殊的队列，它的本质是堆(二叉树)，而且默认为大堆(大的置于前)，属于用堆模仿的队列，是两者的结合体。但是它的优先级是可以由用户通过仿函数调整的，能够实现出插入数据就自动排好序的功能。那么本篇我们就用C++来模拟实现一个优先级队列。

2.1基本实现功能

​ 作为一个队列，我们需要实现以下基本接口

push() //压入数据

pop() //删除数据

top() //取队头数据

size() //取大小

empty() //判空

还要通过模板参数来实现控制大堆还是小堆的仿函数。

因为这里优先级队列的精华是：通过模板参数来控制究竟是大堆还是小堆，而不是重新再写一遍，提高代码复用率。

注意： 仿函数是一种可以用来控制比较规则的结构体或类。通过重载（）运算符 来实现。

template<class T>  //模板参数T为类型名
	struct Less	//大堆的仿函数：因为是Less往数小方向走，所以称“Less”
	{
		bool operator()(const T& x, const T& y)
		{
			return x < y;
		}
	};

	template<class T>
	struct Greater//小堆的仿函数：因为是Greater往数大方向走，所以称“Greater”
	{
		bool operator()(const T& x, const T& y)
		{
			return x > y;
		}
	};

---

2.2具体实现

让我们先来实现一下优先级队列的结构和基本接口。

首先是模板参数

template<class T,class Container = vector<T>,class Compare = Less<T>>

**注意：**这里由于是堆，所以默认容器使用vecotr装的，后面的比较规则也默认是大堆。

​ 这里得益于模板，插入数据的类型、容器和比较规则都能手动指定，只要满足接口即可。

所以基本结构为：

template<class T,class Container = vector<T>,class Compare = Less<T>>
	class priority_queue
	{
	public:

		void push(const T& x)
		{}

		void pop()
        {}

		const T& top()
		{}

		size_t size()
        {}

		bool empty()
        {}
        
        void adjust_up(int child) //这里的向上调整和向下调整是为了和堆的结构保持一致
		{}						 //因为堆不能直接插入删除，在尾部插入后需要向前调整
								
		void adjust_down(int parent)
        {}
	private:
		Container _con;
	};

注意： 这里尾部的两个**调整接口adjust_up()和adjust_down()**是为了模仿堆的构成每次插入数据后都会进行排序，以保证它是一个堆。通常会在插入删除接口push()和pop()接口中用到。后面我们会重点讲到这两个接口，有堆基础的小伙伴肯定秒懂~

2.2.1 push() 压入数据

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

​ 用容器的尾插后从尾部向上调整。

2.2.2 pop() 删除数据

void pop()
		{
			swap(_con[0], _con[_con.size() - 1]);
			_con.pop_back();
			adjust_down(0);
		}

堆的删除能直接删吗？ 不能！ 删除会打乱结构顺序。这里由于是用堆模拟的队列，所以需要把需要删除top队顶的数据跟尾部交换后删除，再从头往下调整。

2.2.3 top() 取队顶元素

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

直接利用容器的第一个元素当作队头，返回一个T&类型。

2.2.4 size() 取队列数据大小

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

这里size()，采用容器自带的size()接口封装就好了。

2.2.5 empty() 队列判空

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

这里empty()同理，采用容器自带的接口封装即可。

2.2.6 adjust_up() 向上调整

void adjust_up(int child)
		{
			Compare com; //通过仿函数创建对象，下面通过该对象控制比较逻辑
			int parent = (child - 1) / 2;
			while (child > 0) 
			{
				if (com(_con[parent] ,_con[child])) //如果孩子数值大于父亲
				{
					swap(_con[child], _con[parent]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else
					break;
			}
		}

这里完全就是堆的知识了。在以尾部为起点向前遍历，如果孩子数据大于父亲节点数据就交换，并且更新孩子和父亲。

不过这里的亮点是比较规则。还记得我们前面写的仿函数结构体嘛**？ 采用仿函数结构体生成的com对象，然后用该对象使用（）来控制两者比较规则。**而且具体规则用户说了算！

2.2.7 adjust_down() 向下调整

void adjust_down(int parent) //向下调整，孩子不止有一个！！ 需要判断左右孩子问题
		{
			Compare com;
			int child = parent * 2 + 1;
			while (child < _con.size())
			{
				//...
				//if (child + 1 < _con.size() && _con[child + 1] > _con[child])//右孩子存在且右孩子大于左孩子
				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[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
					break;
			}void adjust_down(int parent) //向下调整，孩子不止有一个！！ 需要判断左右孩子问题
		{
			Compare com;
			int child = parent * 2 + 1;
			while (child < _con.size())
			{
				//...
				//if (child + 1 < _con.size() && _con[child + 1] > _con[child])//右孩子存在且右孩子大于左孩子
				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[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
					break;
			}

​ 这里需要注意的问题是，上面的向上调整是通过孩子节点找父亲，只有一个父亲所以不需要判断父亲到底是谁。

​ 这里的从头向下调整就需要注意，孩子不只有一个，有左右孩子之分。所以上述while循环里面的第一个if判断语句是在将所有孩子分为右孩子来处理。总体和adjust_up无差异。

3.完整代码

​

#pragma once
namespace Arthur
{
		template<class T>
		struct Less
		{
			bool operator()(const T& x, const T& y)
			{
				return x < y;
			}
		};

		template<class T>
		struct Greater
		{
			bool operator()(const T& x, const T& y)
			{
				return x > y;
			}
		};

	template<class T,class Container = vector<T>,class Compare = Less<T>>
	class priority_queue
	{
	public:

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

		void adjust_down(int parent) //向下调整，孩子不止有一个！！ 需要判断左右孩子问题
		{
			Compare com;
			int child = parent * 2 + 1;
			while (child < _con.size())
			{
				//...
				//if (child + 1 < _con.size() && _con[child + 1] > _con[child])//右孩子存在且右孩子大于左孩子
				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[child], _con[parent]);
					parent = child;
					child = parent * 2 + 1;
				}
				else
					break;
			}


		}
		void push(const T& x)
		{
			_con.push_back(x);
			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;
	};



	void test_Priority_queue()
	{
		priority_queue<int> pq;
		//priority_queue<int,vector<int>,Greater<int>> pq;
		pq.push(1);
		pq.push(5);
		pq.push(7);
		pq.push(2);
		pq.push(3);
		pq.push(19);


		while (!pq.empty())
		{
			cout << pq.top() << " ";
			pq.pop();
		}

	}
}

4.测试结果

先测试默认大堆情况

之后测试手动控制小堆的情况

结果成功展示！！

如果觉得文章对你有帮助的话，麻烦手动点个赞吧！！！

如果你还想关注我更多的文章内容，请访问：

C++List的简单模拟实现
C++模拟底层实现vector
C++多态详解