二叉堆/优先队列

#include<iostream>
#include<vector>
#include<algorithm>

template <typename T>
class BinayHeap
{
public:
	explicit BinayHeap(int capacity=100)
	{
		array.resize(100,0);
		cur_size=0;
	}
	explicit BinayHeap(std::vector<T>& items):array(items.size()+10),cur_size(items.size())
	{
		std::copy(items.begin(),items.end(),array.begin()+1);
		build_heap();
	}
	bool is_empty()
	{
		if(cur_size==0){
			return true;
		}
		return false;
	}
    const T& find_min()
	{
		if(is_empty()){
			return NULL;
		}
		reutrn array[1];
	}
	void insert_item(const T&item)
	{
		if(cur_size==array.size()-1){
			array.resize(array.size()*2);
		}
		int hole=++cur_size;
		while(hole>1){
			if(array[hole/2]>item){
				std::swap(array[hole/2],array[hole]);
			}else{
				break;
			}
			hole=hole/2;

		}
		array[hole]=item;
	}
	void delete_min()
	{
		if(is_empty()){
			return;
		}
		array[1]=array[cur_size--];
		percolate_down(1);
	}
	void make_empty()
	{
		
		cur_size=0;
	    array.swap( std::vector() );
		array.resize(100,0);

	}
private:
	int cur_size;
	std::vector<T> array;
	void build_heap()
	{
		for(int i=cur_size/2;i>0;i--){
			percolate_down(i);
		}
	}
	void percolate_down(int hole)
	{

		T temp=array[hole];
		int child(0);
		while((child=hole*2)<=cur_size){
			if(child!=cur_size){
				if(array[child]>array[child+1]){
					child++;
				}
			}
			if(array[child]<temp){
				array[hole]=array[child];
			}else{
				break;
			}
		
			hole=child;
		}
		array[hole]=temp;

	}
	
};

int main()
{

	std::vector<int> items;
	items.push_back(5);
	items.push_back(1);
	items.push_back(3);
	items.push_back(2);

	BinayHeap<int> binary_heap(items);
    getchar();
}