数据结构与算法——二叉堆

二叉堆（也叫做堆）：

本次实现的是最小堆，也就是树的根结点的值是最小的。如果树的根结点的值是最大的，那么该堆是最大堆。

堆是一颗完全二叉树，一颗树高为h的完全二叉树有2^k到2^(k+1)-1个结点，二叉树的高为log(N)
因为二叉树非常有规律，我们用数组来表示二叉树，在数组中我们从数组下标为1处开始存储。
对于数组任意位置i上的元素，其左儿子在2*i上，右儿子在（2*i+1)上，它的父亲则在i/2上。
在堆中，任意一结点的值小于其子结点的值，所以根据最小堆的性质，最小元素总是会在树的根结点处找到。

主要的接口:

插入insert

删除最小元素deleteMin

判断是否为空isEmpty

二叉堆类：

/*************************************************************************
	> File Name: BinaryHeap.h
	> Author: 
	> Mail: 
	> Created Time: 2016年01月09日 星期六 14时28分57秒
 ************************************************************************/

#ifndef _BINARYHEAP_H
#define _BINARYHEAP_H

#include <vector>
#include <iostream>
using std::vector;
using std::cout;
using std::cin;
using std::endl;

template<class Comparable>
class BinaryHeap{
    public:
        explicit BinaryHeap(int capacity = 100):currentSize(capacity){}
        explicit BinaryHeap(const vector<Comparable> & items);

        bool isEmpty() const;
        const Comparable & findMin() const;
        
        void insert(const Comparable & x);
        void deleteMin();
        void deleteMin(Comparable & minItem);
        void makeEmpty();
        void output();
    private:
        int currentSize;
        vector<Comparable> array;
        
        void buildHeap();
        void percolateDown(int hole);
};


template<class Comparable>
BinaryHeap<Comparable>::BinaryHeap(const vector<Comparable> & items):array(items.size() + 10), currentSize(items.size())
{
    for (int i = 0; i < items.size(); ++i)
        array[i + 1] = items[i];

    buildHeap();
}

template<class Comparable>
void BinaryHeap<Comparable>::buildHeap()
{
    for (int i = currentSize/2; i > 0; i--){
        percolateDown(i);
    }
}

template<class Comparable>
void BinaryHeap<Comparable>::output()
{
    std::cout << "堆：";
    for (int i = 0; i < currentSize; ++i)
        cout << array[i+1] << " ";
    cout << endl;
}

template<class Comparable>
bool BinaryHeap<Comparable>::isEmpty() const
{
    return currentSize == 0;    
}
template<class Comparable>
void BinaryHeap<Comparable>::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;
}
/*删除最小值，也就是删除堆的根*/
template<class Comparable>
void BinaryHeap<Comparable>::deleteMin()
{
    if(isEmpty()){
        cout << "这是一个空树。" << endl;
        return;
    }
    
    array[1] = array[currentSize--];
    percolateDown(1);
}

/*删除最小值，也就是删除堆的根, 并得到该最小值保存到minItem中*/
template<class Comparable>
void BinaryHeap<Comparable>::deleteMin(Comparable & minItem)
{
    if(isEmpty()){
        cout << "这是一个空树。" << endl;
        return;
    }
    minItem = array[1]; 
    array[1] = array[currentSize--];
    percolateDown(1);
}

template<class Comparable>
void BinaryHeap<Comparable>::percolateDown(int hole)
{
    int child;
    Comparable tmp = array[hole];
    for (; hole * 2 <= currentSize; hole = child){
        child = hole * 2;//left child node

        if(child != currentSize && array[child+1] < array[child]){//right child node < left child node
            child++;
        }

        if(array[child] < tmp)//less child node < parent node
            array[hole] = array[child];//将最小的子结点放在父结点的位置
        else
            break;
    }

    array[hole] = tmp;
}


#endif

实例：

/*************************************************************************
	> File Name: use_binary_heap.cpp
	> Author: 
	> Mail: 
	> Created Time: 2016年01月09日 星期六 15时43分24秒
 ************************************************************************/

#include <iostream>
#include "BinaryHeap.h"
using namespace std;

int main()
{
    vector<int> v;
    v.push_back(14);
    v.push_back(16);
    v.push_back(19);
    v.push_back(21);
    v.push_back(19);
    v.push_back(68);
    v.push_back(13);
    v.push_back(65);
    v.push_back(26);
    v.push_back(32);
    v.push_back(31);

    BinaryHeap<int> binHeap(v); 
    binHeap.output();

    vector<int> v2;
    v2.push_back(150);
    v2.push_back(80);
    v2.push_back(40);
    v2.push_back(30);
    v2.push_back(10);
    v2.push_back(70);
    v2.push_back(110);
    v2.push_back(100);
    v2.push_back(20);
    v2.push_back(90);
    v2.push_back(60);
    v2.push_back(50);
    v2.push_back(120);
    v2.push_back(140);
    v2.push_back(130);
    
    BinaryHeap<int> bindHeap2(v2);
    bindHeap2.output();
    cout << "获得最小元素并删除最小元素：";
    int minVal;
    bindHeap2.deleteMin(minVal);
    cout << minVal << endl;
    bindHeap2.output();

    return 0;
}

参考：数据结构与算法分析C++描述（6.3节---二叉树）