堆的c++类模板实现

我是新手，这个纯属练手，错误勿喷。

#ifndef HEAP_H

#define HEAP_H

#include<iostream>

/*这是一个用模板实现的堆类，支持各种数据类型*/

//如果你要用这个堆存放其他类的对象，请重载>和<，大于号和小于号

template <class T>

class heap {

public:

 //构造函数，默认的最大堆容量是100，第四个参数是设置最大堆还是最小堆的

 //默认min==true是最小堆

 heap(T* array,int size,int capacity=100,bool min=true);

 //析构函数

 virtual ~heap();

 //拷贝构造函数

 heap(const heap& H);

 //构造函数，用来用一个堆来构造一个更大的堆，第二个参数是大小

 //只有这个参数比原来的大小大，才会构建这个大小的堆，否则大小和以前一样

 heap(const heap& H,int cap);

 //堆的上滤操作，把堆的最后一个数据向上移动，直到满足堆的大小关系才停止

 void PrecUp();

 //堆的下滤操作，把堆的某个数据（依据参数，默认为第一个）向下移动

 //直到满足堆的大小关系才停止

 void PrecDown(int position=0);

 //插入堆

 bool Insert(T data);

 //删除堆顶元素

 T Pop();

 //建立堆

 void Build();

 //找父节点

 inline int Parent(int x) { return (x-1)/2; }

 //找左子节点

 inline int Lson(int x) { return 2*x+1; }

 //找右子节点

 inline int Rson(int x) { return 2*x+2; }

 //打印堆中数据

 void ShowHeap();

 //友元函数，用来复制一个数组

 template <typename TT>friend void CopyArray(TT* array,TT* data,int size);

 

private:

 int capacity;//堆容量

 int size;//堆当前大小

 T* array;//堆的数据

 bool min;//TRUE为最小堆，false为最大堆

};

#define Position int//便于理解

template <class T>

static void CopyArray(T* array,T* data,int size)

{

 int i;

 for(i=0;i<size;i++)

 {

  array[i]=data[i];

 }

}

template <class T>

heap<T>::heap(T* a,int Size,int Cap,bool Min)

 {

  size=Size;

  capacity=Cap;

  min=Min;

  this->array=new T[capacity];

  if(a)

   ::CopyArray(array,a,size);

 }

 //template <class T>

 //heap<T>::heap(int size,int capacity,bool min):

 //size(size),capacity(capacity),min(min)

 //{

 // array=new T[capacity];

 //}

 template <class T>

 heap<T>::~heap(){delete[] array;}

 template <class T>

 heap<T>::heap(const heap& H)

 {

  this->size=H.size;

  this->capacity=H.capacity;

  this->min=H.min;

  this->array=new T[size];

  ::CopyArray(this->array,H.array,H.size);

 }

 template <class T>

 heap<T>::heap(const heap& H,int cap)

 {

  this->size=H.size;

  if(cap>H.capacity)

   this->capacity=cap;

  else 

   this->capacity=H.capacity;

  this->min=H.min;

  this->array=new T[size];

  ::CopyArray(this->array,H.array,H.size);

 }

 template <class T>

 void heap<T>::PrecUp()

 {

  Position i=size-1;

  T temp=array[i];

  if(min==true)

  { 

   for(;i>=0;i=Parent(i))

   {

    if(temp>array[Parent(i)])

     break;

    else 

     array[i]=array[Parent(i)]; 

    if(i==0)

     break;

   }

   array[i]=temp;

  }

  else 

  {

   for(;i>=0;i=Parent(i))

   {

    if(temp<array[Parent(i)])

     break;

    else 

     array[i]=array[Parent(i)]; 

    if(i==0)

     break;

   }

   array[i]=temp;

   

  }

    

 }

 template <class T>

 void heap<T>::PrecDown(int position)

 {

  Position i=position;

  Position next;

  T temp=array[i];

  if(min==true)

  {

   for(;i<size;i=next)

   {

    next=Lson(i);

    if(array[next]>array[next+1]) 

     next++;

    if(temp>array[next])

     array[i]=array[next];

    else 

     break; 

    if(next>size-1)

     break;

   }

   array[i]=temp;

  }

  else if(min==false)

  {

   for(;i<size;i=next)

   {

    next=Lson(i);

    if(array[next]<array[next+1]) 

     next++;

    if(temp<array[next])

     array[i]=array[next];

    else 

     break; 

    if(next>size-1)

     break;

   }

   array[i]=temp;

  }

 }

 template <class T>

 bool heap<T>::Insert(T data)

 {

  if(capacity==size)

   return false;

  array[size++]=data;

  PrecUp();  

 }

 template <class T>

 T heap<T>::Pop()

 {

  T re=array[0];

  array[0]=array[--size];

  PrecDown();

 }

 template <class T>

 void heap<T>::Build()

 {

  Position i=Parent(size-1);

  for(;i>=0;i--)

  {

   PrecDown(i);

  }

 }

 template <class T>

 void heap<T>::ShowHeap()

 {

  int i;

  for(i=0;i<size;i++)

  {

   std::cout<<array[i]<<' ';

  }

  std::cout<<std::endl;

 }

 

 

#endif