用数组实现的最大堆(C++)

#include <iostream>
#include <assert.h>

using namespace std;
void swap(int* a,int pos,int j){
    int temp=a[pos];
    a[pos]=a[j];
    a[j]=temp;
}
class heap{
private:
    int* Heap;
    int maxsize;  //堆的大小
    int n;        //当前堆中的元素个数

    //把一个元素移动到合适的位置
    void shiftdown(int pos){
      while(!isLeaf(pos)){     //如果是叶子结点就停止
        int j=leftchild(pos);
        int rc=rightchild(pos);
        if((rc<n)&&Heap[rc]>Heap[j])
            j=rc;               //把j设置为最大孩子的下标
        if(Heap[pos]>Heap[j])
            return;           //当前结点数值比两个孩子最大值还大就结束了
        swap(Heap,pos,j);
        pos=j;
      }
    }

public:
    heap(int* h,int num,int maxi){  //构造函数
        Heap=h;
        n=num;
        maxsize=maxi;
        buildHeap();
    }
    int size()const{         //返回当前个数
        return n;
    }
    bool isLeaf(int pos) const{  //判断是否是叶子
        return (pos>=n/2)&&(pos<n);
    }
    int leftchild(int pos) const{  //返回结点左孩子
        return 2*pos+1;
    }
    int rightchild(int pos) const{  //返回结点右孩子
        return 2*pos+2;
    }
    int parent(int pos) const{       //返回父亲结点
        return (pos-1)/2;
    }
    void buildHeap(){            //把堆进行堆化
        for(int i=n/2-1;i>=0;i--)
            shiftdown(i);
    }
    //把一个元素插入堆
    void insert(const int& it){
        assert(n<maxsize);
        int curr=n++;
        Heap[curr]=it;  //把元素插入到堆的最后
        //把这个元素向上移动
        while((curr!=0)&&(Heap[curr]>Heap[parent(curr)])){
            swap(Heap,curr,parent(curr));
            curr=parent(curr);
        }
    }
    int remove(int pos){     //移除一个结点
        assert((pos>=0)&&(pos<n));
        if(pos==(n-1))  //如果是最后一个元素
            n--;
        else{
            swap(Heap,pos,--n);
            while((pos!=0)&&(Heap[pos]>Heap[parent(pos)])){
                swap(Heap,pos,parent(pos));
                pos=parent(pos);
            }
            if(n!=0)
                shiftdown(pos);
        }
        return Heap[n];
    }
};