优先队列--模板类实现

#include<iostream>

template<class Data>
class PriQueue
{
public:
    PriQueue();
    Data DelMin();
    int Insert(Data);
    ~PriQueue();
    //for debug===========
    void List();

    template<Data> friend std::ostream& operator << (std::ostream& , const PriQueue<Data>&);
    template<Data> friend std::istream& operator >> (std::istream& , PriQueue<Data>&);
    // ====for debug
private:
    Data* data;
    unsigned int end;//最后一个元素的后一个下标，第一个可用单元 
    unsigned int remain;//剩下的可用单元 
    void swap(unsigned int,unsigned int);
    //测试用---- 
    int Getdata(unsigned int);
    ------------ 
};
template<class Data>
int PriQueue<Data>::Getdata(unsigned int index)
{
    return data[index];
}

template<class Data>
void PriQueue<Data>::List()
{  if (end==1) return;
    for (int i=1;i<end;i++)
        std::cout<<data[i]<<"  ";
        std::cout<<"end: "<<end<<"; remain: "<<remain<<std::endl;
}
template<class Data>
PriQueue<Data>::PriQueue()
{


    end=1;
    data=new Data[100];
    remain=99;



}
template<class Data>
void PriQueue<Data>::swap(unsigned int index1,unsigned int index2)
{
    Data tmp=data[index1];
    data[index1]=data[index2];
    data[index2]=tmp;

}
template<class Data>
int PriQueue<Data>::Insert(Data elem)
{
    if (remain==0) return 0;
    data[end]=elem;

    unsigned int tmp=end;
    while ( tmp/2>0 && data[tmp]<data[tmp/2])//上滤
    {
        swap(tmp,tmp/2);
        tmp/=2;

    }
    end++;
    remain--;
    return 1;
}

template<class Data>
Data PriQueue<Data>::DelMin()
{ Data ret;
    if(end>1)
	ret=data[1];
	else return 0;
    unsigned int tmp=1;
    while (tmp*2+1<end)
    {

        if (data[2*tmp]<data[2*tmp+1])
        {
            data[tmp]=data[tmp*2];
            tmp*=2;
        }
        else
        {
            data[tmp]=data[tmp*2+1];
            tmp=tmp*2+1;
        }


    }
   
    
       if(tmp*2+1==end)
        data[tmp]=data[2*tmp];
       
    
    end--;
    remain++;
    return ret;

}



template<class Data>
PriQueue<Data>::~PriQueue()
{

    delete[] data;

}

template<class Data>
std::istream& operator >> (std::istream& is, PriQueue<Data>& ob)

{
    Data da;

    is>>da;
    ob.Insert(da);
    return is;

}
template<class Data>
std::ostream& operator<<(std::ostream &out,const PriQueue<Data>& s)
{
    out<<s.Getdata();
    return out;

}
int main()
{
    PriQueue<int> que;
    
        que.Insert(2);
        que.Insert(4);
   
	std::cout<<que.DelMin()<<std::endl;
		
    std::cout<<que.DelMin()<<std::endl;
       
    return 0;

}

关于内存池的实现，哈哈，以后有时间在补上。。