c++ 实现优先级队列(模板)

1.特性及和队列的区别

首先我们来看队列：队列是一种先进先出的数据结构，它是按照元素的入队时间顺序来出队的；而优先级队列是按照优先级来进行处理，即不是将队头元素出队，而是先将队列中优先级最高的元素出队，我们一般借助堆来选出优先级高的元素

2.堆的简单描述

堆是一种特殊的队列，从堆中取出元素不是按照入队顺序，而是按照元素优先级大小。堆是一颗完全二叉树，分为大堆和小堆，出对元素的值是队列中的最大值时，称为大堆，反之为小堆；

3.实现

实现主要是堆的思想，也就是向下调整和向上调整

• 模板参数列表：T为数据类型；Container为选择的底层容器类型，我们这里默认使用vector；Com为比较大小的方式，默认less方式，构造出大堆（对于自定义类型的数据比较，我们要通过重载（）来比较大小）
• 构造函数：

1. 无参构造
2. 区间构造，先将区间元素全部拷贝到当前容器中，然后开始从最后一个父节点进行向下调整，一直调整到队头元素位置

• 父节点parent=（child-1）/2即parent = （child-1）>>1;
• 左孩子节点 child = parent*2+1;右孩子节点 child =parent*2+2;
• 向下调整根据Com比较当前节点（parent）和孩子节点（child/child+1）结果来进行向下调整，直到 patent 与它的孩子们不满足Com条件（目的将该节点调整到满足com条件的位置）
• 向上调整根据Com比较当前节点（child）和夫子节点（parent），来向上调整，直到child调整满足com条件的位置；
• push：将新元素先插入队尾，用向上调整，将他调整到合适的位置
• pop：将队头元素队尾元素交换，删除队尾元素，再将队头元素向下调整到合适的位置
• 其他操错很简单，不再赘述

	//优先级序列
	template,class Com=less>
	class priority_queue {
	public:
		priority_queue() {}//无参构造，自动调用容器的构造函数
		template
		priority_queue(Iterator first, Iterator last) //区间构造（迭代器实现）
			:con(first,last)
		{
			int count = (int)con.size();
			int root = (count - 1 - 1) >> 1;
			while (root >= 0) {
				AdjustDown(root);
				root--;
			}
		}
		const T& top()const {//堆顶元素不允许修改，否则可能改变堆的结构
			return con.front();
		}
		void push(const T& data) {
			//尾插一个新的叶子节点
			//该叶子节点向上调整
			con.push_back(data);
			AdjustUp(size()-1);
		}
		void pop() {
			//1.交换头节点和最后一个叶子节点
			//2.删除最后一个叶子节点
			//3.头节点向下调整
			if (con.empty()) {
				return;
			}
			swap(con.front(), con.back());
			con.pop_back();
			AdjustDown(0);
			
		}
		bool empty() {
			return con.empty();
		}
		size_t size() {
			return con.size();
		}
	private:
		void AdjustDown(size_t parent) {
			size_t child = parent * 2 + 1;
			while (child < con.size()) {
				if (child + 1 < con.size() && com(con[child], con[child + 1])) {
					child = child + 1;
				}

				if (com(con[parent], con[child])) {
					swap(con[parent], con[child]);
					parent = child;
					child = parent * 2 + 1;
				}
				else {
					return;
				}
			}
		}
		void AdjustUp(size_t child) {
			if (child >= con.size()) {
				return;
			}
			size_t parent = (child - 1) / 2;
			while (child) {
				if (com(con[parent], con[child])) {
					swap(con[parent], con[child]);
					child = parent;
					parent = (child - 1) / 2;
				}
				else {
					return;
				}

			}
		}
	private:
		Container con;
		Com com;
	};