堆与优先级队列实现

#include<iostream>
using namespace std;
#include <vector>
#include<assert.h>

template<class T>
struct Less
{
	bool operator()(const T& left,const T& right)
	{
		return left<right;
	}
};
template<class T>
struct Greater
{
	bool operator()(const T& left,const T& right)
	{
		return left>right;
	}
};
template<class T,class Compare=Less<T>>
class Heap
{
public:
	// 创建一个空堆
	Heap()
	{}

	Heap(const T array[], size_t size)
	{
		_heap.resize(size);
		for(size_t idx=0;idx<size;idx++)
		{
			_heap[idx]=array[idx];
		}
		int root=(_heap.size()-2)>>1;
		for(;root>=0;root--)
		{
			_AdjustDown(root);
		}
	}
	size_t Size()const
	{
		return _heap.size();
	}
	const T& Top()const
	{
		assert(!_heap.empty());
		return _heap[0];
	}
	bool Empty()const
	{
		return _heap.empty();
	}
	void Insert(const T& data)
	{
		_heap.push_back(data);
		if(_heap.size()>1)
		{
			_AdjustUp();
		}
	}
	void Remove()
	{
		assert(!_heap.empty());
		if(_heap.size()>1)
		{
			std::swap(_heap[0],_heap[_heap.size()-1]);
			_heap.pop_back();
			_AdjustDown(0);
		}
	}

protected:
	void _AdjustDown(size_t parent)
	{
		size_t child=parent*2+1;
		while(child<_heap.size())
		{
			Compare com;
			if(child+1<_heap.size()&&com(_heap[child+1],_heap[child]))
				child+=1;
			if(com(_heap[child],_heap[parent]))
			{
				std::swap(_heap[parent],_heap[child]);
				parent=child;
				child=parent*2+1;
			}
			else
				return;
		}
	}
	void _AdjustUp()
	{
		size_t child=_heap.size()-1;
		size_t parent=(child-1)>>1;
		while(child!=0)
		{
			if(Compare()(_heap[child],_heap[parent]))
			{
				std::swap(_heap[child],_heap[parent]);
				child=parent;
				parent=(child-1)>>1;
			}
			else
				return;
		}
	}
protected:
	std::vector<T> _heap;
};




/////优先级队列
template<class T, class Compare = Less<T>>
class PriorityQueue
{
public:
	PriorityQueue()
	{}
	void Push(const T& data)
	{
		_hp.Insert(data);
	}
	void Pop()
	{
		_hp.Remove();
	}
	const T& Top()const
	{
		return _hp.Top();
	}
	size_t Size()const
	{
		return _hp.Size();
	}
	bool Empty()const
	{
		return _hp.Empty();
	}
protected:
	Heap<T, Compare> _hp;
};
int main()
{
	int arr[]={53,17,78,9,45,65,87,23};
	Heap<int,Greater<int>> s(arr,8);
	return 0;
}