大顶堆的C++模板实现及二叉堆的简介

何为二叉堆？

二叉堆是一种特殊的堆，二叉堆是完全二叉树或者近似完全二叉树。二叉堆满足堆特性：父节点的键值总是保持固定的序关系于任何一个子节点的键值，且每个节点的左右子树都是一个二叉堆。

当父节点的键值总是大于或等于任何一个子节点的键值时为最大堆(大顶堆)。
当父节点的键值总是小于或等于任何一个子节点的键值时为最小堆(小顶堆)。

根据二叉树的性质，可得：
1. 如果根节点在数组的位置是1,第n个位置的子节点分别在2n和2n+1，第n个位置的双亲节点在[i/2]。因此，第1个位置的子节点在2和3。
2. 如果根节点在数组的位置是0,第n个位置的子节点分别在2n+1和2n+2，第n个位置的双亲节点在[(i-1)/2]。因此，第0个位置的子节点在1和2。

二叉堆一般用数组来表示，得益于数组的随机存储能力，我们能够很快确定堆中节点的父节点和子节点。

在本文中，我们主要介绍大顶堆的C++模板实现过程，以根节点在0位置存储为例。

二叉堆的具体实现

1. 二叉堆的抽象数据类型

/*大顶堆类定义*/
template <typename T>
class MaxHeap
{
public:
    MaxHeap(int cap);
   ~MaxHeap();

    bool insert(T val);     //往二叉堆中插入元素
    bool remove(T val);     //从二叉堆中删除元素
    void print();           //打印二叉堆
    T    getTop();          //获取堆顶元素
    bool creatMaxHeap(T a[],int size);//根据指定数组创建大顶堆

private:

    int ArraySize;      //数组的大小
    int size;           //堆的大小，数组中有效元素的个数
    T*  maxheap;        //底层数组

    //从index节点往根节点调整堆
    void filterUp(int index);
    //从begin节点向end节点调整堆
    void filterDown(int begin,int end);

};

2. 构造函数与析构函数

/*构造函数*/
template <typename T>
MaxHeap<T>::MaxHeap(int cap)
{
    ArraySize = cap;   //初始化数组的大小
    size = 0;　　　　　　
    maxheap = new T[ArraySize]; //开辟空间
};
/*析构函数*/
template <typename T>
MaxHeap<T>::~MaxHeap()
{
    delete []maxheap;　　　　　　//释放空间　　
}

3. 大顶堆的插入

在数组的最末尾插入节点，然后自上而下地调整子节点与父节点的位置：比较当前节点与父节点的大小，若不满足大顶堆的性质，则交换两节点。时间复杂度为O(log n)。

/*从下往上调整堆--插入元素时使用*/
template <typename T>
void MaxHeap<T>::filterUp(int index)
{
    //记录下当前节点
    T value = maxheap[index];
    while(index>0)
    {
        //得到其双亲节点
        int indexparent = (index - 1) / 2;

        if(value < maxheap[indexparent])
            break;
        else  //交换两节点
        {
            //新节点被其父节点覆盖
            maxheap[index] = maxheap[indexparent];
            //记录下新节点的位置
            index = indexparent;   
        }
    }
    //给新节点赋值
    maxheap[index] = value;
};

/*插入元素*/
template<typename T>
bool MaxHeap<T>::insert(T val)
{
    if(ArraySize == size)  //如果数组放不下
        return false;
    maxheap[size] = val;   //数组末尾放入新节点
    filterUp(size);        //自下而上调整节点
    size++;                //堆的元素数量加1
    return true;
};

实际编码过程中，我们不进行节点的交换，我们直接使用父节点覆盖当前节点，然后记录新节点的位置，最后直接把新节点放入它最后的位置即可。

4. 大顶堆的删除

堆删除节点的过程：用数组最末尾节点覆盖被删结点，然后数组的有效元素(即堆中的元素)数量减1，再由该节点从上到下调整二叉堆。

/*从上到下调整堆--删除元素时使用*/
template <typename T>
void MaxHeap<T>::filterDown(int current,int end)
{
    int child = current * 2 + 1;  //当前结点的左孩子

    T value = maxheap[current];  //保存当前节点

    while(child <= end)
    {
        //选出两个孩子中较大的孩子
        if(child < end && maxheap[child] < maxheap[child + 1])
            child++;  
        if(value > maxheap[child])//无需调整
            break;
        else
        {
            maxheap[current] = maxheap[child]; //孩子节点覆盖当前节点
            current = child;                   //当前节点为较大的孩子节点
            child = child * 2 + 1;             //child重新指向当前节点的左孩子节点
        }
    }
    maxheap[current] = value;                  //找到合理地位置后 赋值
};
/*删除元素*/
template <typename T>
bool MaxHeap<T>::remove(T key)
{
    if(size == 0)
        return false;
    int index;  //被删除元素的下标

    for(index = 0; index < size; index++)
    {

        if(maxheap[index] == key)
            break;  //找到被删元素的下标
    }

    if(index == size) 
        return false;  //数组中没有要删除的元素

    //使用数组最后一个元素来代替该被删除元素
    maxheap[index] = maxheap[size - 1];

    //覆盖完成后　从上到下调整堆
    filterDown(index,size--);

    return true;
};

5. 其他操作

/*获取堆顶元素*/
template <typename T>
T MaxHeap<T>::getTop()
{
    if(size != 0)
        return maxheap[0];    
};

/*打印大顶堆*/
template <typename T>
void MaxHeap<T>::print()
{
    for(int i=0; i<size; i++)
        cout << maxheap[i] << " ";
    cout << endl;
};

/*根据指定数组创建大顶堆*/
template <typename T>
bool MaxHeap<T>::creatMaxHeap(T a[],int size)
{
    if(ArraySize < size)
        return false;
    for(int i=0; i<size; i++)
        insert(a[i]);

    return true;
};

6. 测试代码

int main()
{
    MaxHeap<int> heap1(11);

    //逐个元素创建大顶堆
    for(int i=0; i<10; i++)
        heap1.insert(i);
    cout << "堆顶元素为：" << heap1.getTop() << endl;
    heap1.print();

    /*从堆中删除元素5*/
    heap1.remove(5);
    heap1.print();

    //根据指定数组创建大顶堆*/
    int array[10] = { 1,2,3,4,5,6,7,8,9,10 };
    MaxHeap<int> heap2(11);
    heap2.creatMaxHeap(array,10);
    cout << "堆顶元素为：" << heap2.getTop() << endl;
    heap2.print();

    return 0;
}

7. 输出结果

堆顶元素为：9
9 8 5 6 7 1 4 0 3 2 
9 8 4 6 7 1 2 0 3 
堆顶元素为：10
10 9 6 7 8 2 5 1 4 3 

---

ok,all right.