二叉堆（最小堆）（数据结构与算法分析的代码实现）

“堆是一棵被完全填满的二叉树，可能的例外是在底层，底层上的元素从左到右填入。这样的树称为完全二叉树”

“因为完全二叉树很有规律，所以可以用一个数组表示而不需要使用链”

上面两句是摘自《数据结构与算法分析》

书中代码的上滤和下滤的实现比算法导论的好，算法导论通过递归，每一次都交换不合适的节点，书本的代码则是通过循环找到节点正在要移动到的位置。

参考算法导论的代码：http://www.cnblogs.com/alan-forever/archive/2012/09/26/2704860.html

算法导论的是堆排序的代码，不过堆的性质都有的。

下面的代码是最小堆的，而且是一个类模板。

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

template <typename Comparable>
class BinaryHeap
{
public:
    explicit BinaryHeap( int capacity = 100 ) : array( capacity + 10 )
    {
        currentSize = 0;
    }

    explicit BinaryHeap( const vector<Comparable> & item ) : array( item.size() + 10 ), currentSize( item.size() )
    {
        for(int i = 0; i < item.size(); ++i)
            array[i+1] = item[i];
        buildHeap();
    }

    bool isEmpty() const
    {
        return currentSize == 0;
    }

    const Comparable & finMin( ) const
    {
        return array[1];
    }

    void insert( const Comparable & x)
    {
        if(currentSize == array.size() - 1)
            array.resize( array.size() * 2);

        int hole = ++currentSize;
        for(; hole > 1 && x < array[hole / 2]; hole /= 2)
            array[hole] = array[hole / 2];
        array[hole] = x;
    }

    void deleteMin()
    {
        array[1] = array[currentSize--];
        percolateDowm( 1 );
    }

    void deleteMin(Comparable & Min)
    {
        Min = array[1];
        deleteMin();
    }

    void makeEmpty()
    {
        delete array[currentSize];
        currentSize = 0;
    }

    void print( )
    {
        for(int i = 1; i <= currentSize; ++i)
            cout << array[i] << " ";
        cout << endl;
    }

private:
    int currentSize;
    vector<Comparable> array;

    void buildHeap()
    {
        for(int i = currentSize / 2; i > 0; i--)
            percolateDowm( i );
    }

    void percolateDowm( int hole )
    {
        int child;
        Comparable temp = array[hole];

        for(; hole * 2 <= currentSize; hole = child)
        {
            child = hole * 2;
            if(child != currentSize && array[child + 1] < array[child])
                child++;
            if(array[child] < temp)
                array[hole] = array[child];
            else
                break;
        }
        array[hole] = temp;
    }
};

int main()
{
    vector<int> a;
    int m;
    for(int i = 0; i < 10; ++i)
    {
        cin >> m;
        a.push_back( m );
    }
    BinaryHeap<int> minHeap( a );
    cin >> m;
    minHeap.insert( m );
    minHeap.deleteMin();
    minHeap.print();
    return 0;
}