第六章：堆排序

一：二叉堆的基本操作：

假设我们要实现的是一个最小堆：

1：插入操作

代码：

template<class Type>
void binaryHeap<Type>::insert(const Type& val)
{
        if(currentSize==array.size()-1)
                array.resize(array.size()*2);
        int hole=++currentSize;
        while(hole>1&&val<array[hole/2]){
                array[hole]=array[hole/2];
                hole/=2;
        }
        array[hole]=val;
}

2：下滤操作：

template<class Type>
void binaryHeap<Type>::percolateDown(int hole)
{
        int child;
        Type tmp=array[hole];
        while(hole*2<=currentSize){
                child=hole*2;
                if(child!=currentSize&&array[child+1]<array[child])
                        child++;
                if(array[child]<tmp){
                        array[hole]=array[child];
                        hole=child;
                }
                else break;
        }
        array[hole]=tmp;
}

3：删除最小值操作

//将堆中最小值删除，但不返回该最小值；
template<class Type>
void binaryHeap<Type>::deleteMin()
{
        if(isEmpty())
                throw underflow_error("The heap is empty?!");
        array[1]=array[currentSize--];
        percolateDown(1);
}

//将堆中最小值删除，并且返回该最小值；
template<class Type>
void binaryHeap<Type>::deleteMin(Type& min)
{
        if(isEmpty())
                throw underflow_error("The heap is empty?!");
        min=array[1];
        array[1]=array[currentSize--];
        percolateDown(1);
}

二：堆排序

堆排序顾名思义是用二叉堆对一些列元素进行排序，二叉堆用的是最大堆。代码如下：

//下滤操作：
template<class Comparable>
void percDown(vector<Comparable>& a,int i,int n)
{
        int Child;
        Comparable tmp;
        for(tmp=a[i];2*i+1<n;i=Child)
        {
                Child=2*i+1;
                if(Child!=n-1&&a[Child]<a[Child+1])
                        Child++;
                if(tmp<a[Child])
                        a[i]=a[Child];
                else break;
        }
        a[i]=tmp;
}

template<class Comparable>
void heapsort(vector<Comparable>& a)
{
        for(int i=a.size()/2;i>=0;i--)
                percDown(a,i,a.size()); //建立一个最大堆
        for(int j=a.size()-1;j>0;j--)
        {
                swap(a[0],a[j]);     //删除一个最大值
                percDown(a,0,j);   
        }
}