优先级队列的模拟实现

目录

文章目录

一、优先级队列的介绍

一、优先级队列的概念

二、优先级队列的定义

三、基本操作（常见接口的功能）

二、优先级队列的模拟实现

一、构造函数的实现

一、模板参数

二、成员变量

三、无参的默认构造

二、调整算法

一、向下调整算法

二、向上调整算法

三、常见接口的实现

1、push

2、pop

3、top

4、empty size

四、仿函数的实现

全部代码

---

一、优先级队列的介绍

一、优先级队列的概念

优先级队列（priority_queue）其实更像是数据类型中的“堆”。优先级队列每次出队的元素是队列中优先级最高的那个元素，而不是队首的元素。这个优先级可以通过元素的大小等进行定义。比如定义元素越大优先级越高，那么每次出队，都是将当前队列中最大的那个元素出队。个人感觉这就是所谓“优先级”的定义。

现在看优先级队列是不是就是“堆”了，如果最大的元素优先级最高，那么每次出队的就是当前队列中最大的元素，那么队列实际就相当于一个大顶堆，每次将堆根节点元素弹出，重新维护大顶堆，就可以实现一个优先级队列。

1. 优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。
2. 此上下文类似于堆，在堆中可以随时插入元素，并且只能检索最大堆元素(优先队列中位于顶部的元素)。
3. 优先队列被实现为容器适配器，容器适配器即将特定容器类封装作为其底层容器类，queue提供一组特定的成员函数来访问其元素。元素从特定容器的“尾部”弹出，其称为优先队列的顶部。

这是一段官方对于优先级队列的介绍。

二、优先级队列的定义

template <class T, class Container = vector<T>,  class Compare = less<typename Container::value_type> > class priority_queue;
第一个模板参数为为class T，代表每个元素的类型.

第二个模板参数为class Container，缺省值为vector<T>,代表存储这些数据的容器，可以是vector，deque等，但不能是list，因为它的内部空间不连续.

第三个模板参数为class Compare，缺省值为less<T>,其中less是个仿函数，是降序排序，既优先级最大的是容器中最大的元素.又叫比较函数.

当然可以升序排序，把less改为greater即可.

less 和 greater使用的前提是建立在这些数据类型是C++基本的数据类型.

定义类型的试例

    //不写后面两个参数默认为vector，less
    priority_queue<int> pq1;
    //建立一个优先级队列(大堆)，数据类型是int，利用vector容器实现，less（降序）实现
    priority_queue<int, vector<int>, less<int>> pq2;
    //建立一个优先级队列(小堆)，数据类型是int，利用vector容器实现，greater（降序）实现
    priority_queue<int, vector<int>, greater<int>> pq3;

三、基本操作（常见接口的功能）

它的操作与基本队列操作一样，主要有以下接口：

top()  ：返回元素中第一个元素的引用（优先级最高的元素都会被放到顶部，既第一个元素）.

push()：插入一个元素，并重新维护堆，无返回值.

pop() ：删除优先级最高的元素，并重新维护堆无返回值

size() ：返回容器中有效元素的数量，返回队列的大小

empty() ：检测容器是否为空.返回“true”或者“false”.

二、优先级队列的模拟实现

一、构造函数的实现

一、模板参数

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

二、成员变量

    Container _con; 

直接定义一个适配器类型的成员变量就可

三、无参的默认构造

        priority_queue()
        {}

在自己实现了构造函数后，编译器就不会自动实现默认构造，所以这边要自己实现。

二、调整算法

一、向下调整算法

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 = child + 1;
		}
		if (com(_con[parent] , _con[child])) {
			swap(_con[parent], _con[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else {
			break;
		}
	}
}

大概总固体思路是：先根据根节点找到孩子结点，然后判断左右两个孩子结点中的哪个大，默认是孩子结点是左孩子结点，如果右孩子结点比左孩子结点大，那么直接++即可，就是右孩子结点.

然后再判断，如果孩子结点的值大于父节点的值，则交换，并且更新父节点和孩子结点的值.

二、向上调整算法

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

大概总固体思路是：先根据孩子节点找到对应的父节点进行比较，满足条件就交换父子节点的值，然后继续向上寻找父节点

三、常见接口的实现

1、push

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

直接使用适配器的尾插函数来进行插入，然后用向上调整算法调整位置

2、pop

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

先把首尾元素进行交换，然后删除最后一个元素，再进行向下调整

3、top

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

返回首元素，也就是堆中的根节点，直接返回容器的首元素就行

4、empty size

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

这两个都是容器中有的，直接返回容器中对应的函数就可以

四、仿函数的实现

通过我们上面写的向上调整，向下调整算法，发现有一个比较麻烦的地方

就是它其中的每次比较都是大于，既每次都是大顶堆

但是如果我们想要小顶堆怎么办？只能一点一点的改大小于符号 ，很容易就会混和忘记，非常的不方便.

这个时候我们便可以使用仿函数来解决这个问题.这个时候便用到刚开始写的三个模板参数中的第三个参数了.

可以先写两个仿函数，一个用来构造小顶堆，另外的是大顶堆.

template<class T>
		class less
		{
		public:
			bool operator()(const T& l, const T& r)
			{
				return l < r;
			}
		};
		template<class T>
		class greater
		{
		public:
			bool operator()(const T& l, const T& r)
			{
				return l > r;
			}
		};

这样就可以做到在实例化的时候控制实现的是大堆还是小堆了

全部代码

#pragma once
#include<vector>

using namespace std;
namespace bit {
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;
	}
};
template<class T,class Container = vector<T>,class compare = Less<T>>
class priority_queue {
public:
	void adjust_up(size_t child) {
		size_t parent = (child - 1) / 2;
		while (child > 0) {
			compare com;
			if (com(_con[parent],_con[child])  ) {
				swap(_con[child], _con[parent]);
			}
			else {
				break;
			}
			child = parent;
			parent = (child - 1) / 2;
		}
	}
	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 = child + 1;
			}
			if (com(_con[parent] , _con[child])) {
				swap(_con[parent], _con[child]);
				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];
	}
	bool empty() {
		return _con.empty();
	}
	size_t size() {
		return _con.size();
	}
private:
	Container _con;
};
}