最小堆实现代码

参考算法导论、数据结构相关书籍，写得最小堆实现的源代码如下：

//
//--最小堆实例
//

#include <iostream>
#include <vector>
#include <string>
using namespace std;

template<typename Comparable>
class minHeap
{
public:
    explicit minHeap(int capacity = 0);//显示构造函数，只能用于对象的构造而不能用于隐式转换
    explicit minHeap(const vector<Comparable>& items);
    
    bool isEmpty() const;
    Comparable min() const;
    
    void insert(const Comparable& key); //插入关键字
    Comparable extractMin(); //获得最小值并将其删除
    void decreaseKey(int i,Comparable key); //增加优先级
    void increaseKey(int i,Comparable key); //相当于降低优先级
    void remove(int p); //删除堆中位置p的结点，例如OS中非正常终止进程
private:
    int heapsize;
    vector<Comparable> array;
    
    void build_heap(); //建堆
    void minHeapify(int hole); //从位置hole处向下筛选方法
};

template<typename Comparable>
Comparable minHeap<Comparable>::min() const
{
    return array[1];
}

template<typename Comparable>
Comparable minHeap<Comparable>::extractMin() //获取最小值并将其删除
{
    if (heapsize<1)
        cout << "error" << endl;
    else
    {
        Comparable min = array[1];
        array[1] = array[heapsize];
        --heapsize;
        minHeapify(1);
        return min;
    }
}

template<typename Comparable>
void minHeap<Comparable>::decreaseKey(int i,Comparable key)
{
    if (key>array[i])
        cout << "new key is larger than current key!" << endl;
    else
    {
        array[i] = key;
        for(; i>1 && array[i]<array[i/2]; i /= 2)
            array[i] = array[i/2];
        array[i] = key;
    }
}

template<typename Comparable>
void minHeap<Comparable>::increaseKey(int i,Comparable key)
{
    if (key<array[i])
        cout << "new key is smaller than current key!" << endl;
    else
    {
        array[i] = key;
        minHeapify(i);
    }
}

template<typename Comparable>
void minHeap<Comparable>::insert(const Comparable& key)
{
    if(heapsize == array.size()-1)
        array.resize(array.size()*2);
    int hole = ++heapsize;
    for(; hole>1 && key<array[hole/2]; hole /=2) //向上过滤筛选
        array[hole] = array[hole/2];
    array[hole] = key;
}

template<typename Comparable>
void minHeap<Comparable>::minHeapify(int hole) //向下过滤筛选
{
    Comparable tmp = array[hole];
    for (int child = 2*hole; child <= heapsize; child *= 2)
    {
        if (child<heapsize && array[child] > array[child+1])
            ++child;
        if (tmp < array[child])
            break;
        array[hole] = array[child];
        hole = child;
    }
    array[hole] = tmp;
}

template<typename Comparable>
void minHeap<Comparable>::build_heap() //建堆
{
    for (int i = heapsize/2; i>0; --i) //从下往上筛选
        minHeapify(i);
}


template<typename Comparable>
void minHeap<Comparable>::remove(int p) //删除位置p处的元素
{
    array[p] = array[heapsize];
    --heapsize;
    Comparable key = array[p];
    if (key>array[p/2]) //向下筛选
        minHeapify(p);
    else //向上筛选
        for (; p>1,array[p/2]>key; p /=2)
            array[p] = array[p/2];
        array[p] = key;
}

template<typename Comparable> // 构造函数之一
minHeap<Comparable>::minHeap(int campacity)
:    heapsize(campacity)
{
    array.resize(campacity+10);
}

template<typename Comparable> //构造函数之二
minHeap<Comparable>::minHeap(const vector<Comparable>& items)
:array(items.size()+10), heapsize(items.size())
{
    for (int i = 0; i<items.size(); ++i)
        array[i+1] = items[i];
    build_heap();
}

template<typename Comparable> //判断堆是否为空
bool minHeap<Comparable>::isEmpty() const
{
    if (0 == heapsize)
        return true;
    return false;
}


////////////////////////////////////////////////////////////////
template<typename Comparable>
void dumpContents(const string& msg, minHeap<Comparable>& pq)
{
    cout << msg << ":" << endl;
    while (!pq.isEmpty())
    {
        cout << pq.extractMin() << endl;
    }
}

int main()
{
    //测试一
    /*minHeap<int> minPQ;
    minPQ.insert(4);
    minPQ.insert(3);
    minPQ.insert(2);
    minPQ.insert(6);
    minPQ.insert(1);
    minPQ.increaseKey(4,20);
    minPQ.decreaseKey(3,0);
    minPQ.remove(5);
    dumpContents("minPQ",minPQ);*/
    
    //测试二
    vector<int> a;
    a.push_back(10);
    a.push_back(9);
    a.push_back(7);
    a.push_back(6);
    a.push_back(5);
    a.push_back(4);
    minHeap<int> minpQ(a);
    dumpContents("minPQ",minpQ);
    return 0;
}