c++中priority_queue模拟的实现

//使用示例
#include<iostream>
#include<queue>
using namespace std;
//这是自定义优先级的一种格式
template<typename t>
class gt
{
public:
	//如果返回true则b优先，返回false则a优先，所以这里使用gt会生成小堆
	bool operator()(t a, t b)
	{
		return a > b;
	}
private:
};
int main()
{
	priority_queue<int> heap1;//int表示储存的类型
	priority_queue<int, vector<int>> heap2;//这里vector表示使用的底层容器，这里也可以换成deque<int>。
	
	//greater为编译器提供的类模板，默认的优先级是大堆，而使用它可以生成小堆。
	priority_queue<int, vector<int>, greater<int>> heap3;

	//当然也可以自己设计一个优先级方式传入，该方法常常用于储存自定义类型，而内置类型编译器提供的就够用。
	priority_queue<int, vector<int>, gt<int>> heap4;

	//push接口用于存入元素
	heap4.push(2);
	heap4.push(7);
	heap4.push(1);
	heap4.push(5);
	cout << heap4.size() << endl;//size用于计算队列中元素的个数
	while (!heap4.empty())//empty用于判断队列是否为空
	{
		cout << heap4.top() << ' ';//top获取队头元素
		heap4.pop();//pop删除队头元素
	}
	return 0;
}

#include<iostream>
#include<vector>
using namespace std;
namespace byte//用命名空间限制它的作用域，来区别于库里面的优先级队列
{
	template<typename t, class container = vector<t>, class compare = less<t>>
	class priority_queue
	{
	public:
		//...
	private:
		//...
	};
}

private:
	container arr;
	compare comp;

#include<iostream>
#include<vector>
using namespace std;
namespace byte
{
	template<typename t>
	class less
	{
	public:
		//如果返回true则b优先，返回false则a优先，所以这里使用gt会生成小堆
		bool operator()(t a, t b)
		{
			return a < b;
		}
	private:
	};
	template<typename t>
	class greater
	{
	public:
		//如果返回true则b优先，返回false则a优先，所以这里使用gt会生成小堆
		bool operator()(t a, t b)
		{
			return a > b;
		}
	private:
	};

	template<typename t, class container = vector<t>, class compare = less<t>>
	class priority_queue
	{
	public:

		void adjustup()
		{
			int child = arr.size() - 1, father = (child - 1) / 2;
			while (child > 0)
			{
				if (comp(arr[father], arr[child]))
				{
					std::swap(arr[child], arr[father]);
					child = father;
					father = (child - 1) / 2;
				}
				else
				{
					break;
				}
			}
		}
		void adjustdown()
		{
			int father = 0, child = father * 2 + 1;
			while (child < arr.size())
			{
				if (child + 1 < arr.size() && comp(arr[child], arr[child + 1]))
				{
					child++;
				}
				if (comp(arr[father], arr[child]))
				{
					std::swap(arr[child], arr[father]);
					father = child;
					child = father * 2 + 1;
				}
				else
				{
					break;
				}
			}
		}
		void push(t x)
		{
			arr.push_back(x);
			adjustup();
		}
		void pop()
		{
			std::swap(arr[0], arr[arr.size() - 1]);
			arr.pop_back();
			adjustdown();
		}
		t top()
		{
			return arr[0];
		}
		size_t size()
		{
			return arr.size();
		}
		bool empty()
		{
			return arr.size() == 0;
		}
	private:
		container arr;
		compare comp;
	};
}