最大堆maxheap的一个实现

堆有最大堆，和最小堆。

其中最大堆其实相当于一个优先队列，把队列的优先级存进堆里面，就可以实现优先队列的功能。

//基于数组构建最大堆，该堆是二叉树结构
// Parent(r)=(r-1)/2         r!=0
// Leftchild(r)=2r+1         2r+1<n
// Rightchild(r)=2r+2        2r+2<n
//该堆是一个完全二叉树

#include<iostream>
using namespace std;
template<typename type>
class maxheap
{
private:
    type*Heap;                 //用来存堆地数组
    int size;                  //堆的最大 元素数量
    int n;                     //当前堆地数量
    void swap(type*h,int a,int b)
    {
        type temp=h[a];
        h[a]=h[b];
        h[b]=temp;
    }
public:
    maxheap(type*h,int num,int max)
       {Heap=h;n=num;size=max;}
    int heapsize()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  //pos父结点的位置
       {return (pos-1)/2;}
    void siftdown(int pos)    //将当前结点向下移动
    {
        while(!isleaf(pos))
        {
            int j=leftchild(pos);
            int rc=rightchild(pos);
            if((rc<n)&&(Heap[rc]>Heap[j]))j=rc;
            if(Heap[pos]>=Heap[j])return;
            swap(Heap,pos,j);
            pos=j;
        }
    }
    void siftup(int pos)     //将当前结点向上移动
    {
        if(pos>=n)return;
        int curr=pos;
        while(curr!=0&&Heap[curr]>Heap[parent(curr)]){
                swap(Heap,curr,parent(curr));
                curr=parent(curr);
        }
    }
    bool insert(const type&it) //往数组尾部插入一个结点，然后将该插入的结点，向上移动
    {
        if(n>=size)return false;
        int curr=n;
        n++;
        Heap[curr]=it;
        siftup(curr);
//        while(curr!=0)&&(Heap[curr]>Heap[parent(curr)])
//        {
//            swap(Heap,curr,parent(curr));
//            curr=parent(curr);
//        }
        return true;
    }
    bool removemax(type&it) //删除最大值
    {
        if(0==n)return false;
        n--;
        swap(Heap,0,n);
        if(n!=0)siftdown(0);
        it=Heap[n];
        return true;
    }
    bool remove(int pos,type&it)  //删除位置在pos的结点
    {
        if(pos<0||pos>=n)return false;
        n--;
        swap(Heap,pos,n);
        if(Heap[pos]>Heap[parent(pos)])siftup(pos);
        else siftdown(pos);
        it=Heap[n];
        return true;
    }
    void buildHeap() //将插入的原始数组构造成堆结构
    {
        for(int i=n/2-1;i>=0;i--)siftdown(i);
    }
};
int main()
{
    int a[100]={1,2,0,4,1,6};
    maxheap<int>heap(a,6,100);
    heap.buildHeap();
    int temp;
    heap.removemax(temp);
    cout<<temp<<endl;
    heap.removemax(temp);
    cout<<temp<<endl;
}