大小堆的建立

#include<iostream>
#include<cstdlib>
#include<vector>
#include<cassert>
using namespace std;
template<class T>
struct Less
{
bool operator()(T& l,T& r)
{
return l<r;
}
};
template<class T>
struct Great
{
bool operator()(T& l,T& r)
{
return l>r;
}


};
template<class T,template<class> class Compare>
class Heap
{
public:
Heap(const T* a,size_t size)
{
int i=0;
_a.reserve(size);
for(i=0;i<size;i++)
{
_a.push_back(a[i]);
}
for(i=(size-2)/2;i>=0;i--)
{
AdjustDown(i);          //默认大堆建立
}
Display();
}
size_t Size()
{
return _a.size();
}


bool Empyt()
{
return _a.size()==0;
}
void Insert(T& t)
{
_a.push_back(t); 
size_t size=_a.size();
AdjustUp(size-1);
Display();


}
void Delete()
{
size_t size=_a.size();  
        assert(size>0);  
swap(_a[0];_a[size-1]);
_a.pop_back();
AdjustDown(0);
Display();
}
void Display()
{
if(_a.size()!=0)
{
  for(int i=0;i<_a.size();i++)
  {
  cout<<_a[i]<<" ";
  
  }
}
cout<<endl;
}
void Sort()
{
_Sort(_a.size()-1);
Display();

}
protected:
void AdjustDown(size_t parent)            //向下调整算法建立大堆
{
size_t child =parent*2+1;  
        while(child<_a.size())  
        {  
            Compare<T> com;  
        if(child+1<_a.size()&&com(_a[child+1],_a[child]))  
        {  
            ++child;  
        }  
            if(com(_a[child],_a[parent]))  
            {  
            swap(_a[parent],_a[child]);  
            parent=child;  
            child=parent*2+1;  
        }  
        else  
            break;  
}
}
void AdjustUp(size_t child)              //向上调整算法建立小堆
{
assert(!child>_a.size);
Compare<T> com; ;
int parent=(child-1)/2;
while(child>0)
{
if(com(_a[child],_a[parent]))
{
swap(_a[child],_a[parent]);
child=parent;
parent=(child-1)/2;
}
else
break;
}
}
void _Sort(size_t child)
{
int parent=(child-1)/2;
while(child>0)
{
if(_a[child]<_a[parent])
{
swap(_a[child],_a[parent]);
   child=parent;
}
if(_a[child-1]<_a[child])
{
swap(_a[child-1],_a[child]);
}
else 
break;
}

}
private:
vector<T> _a;


};
int main()
{
int a[]= {10,11, 13, 12, 16, 18, 15, 17, 14, 19};
Heap<int,Less> heap(a,sizeof(a)/sizeof(a[0]));
system("pause");
return 0;
}