简单大根堆的实现

//头文件定义--heap.h
#ifndef _MAXHEAP_H_
#define _MAXHEAP_H_
template<class T>
class MaxHeap{
public:
    MaxHeap(int size=10);
    virtual ~MaxHeap();

    bool IsEmpty();
    void Pop();
    void Push(const T&);
    const T& Top()const;
private:
    int current_size;//堆的当前节点个数
    int max_size;//设置堆的最大节点个数
    T *heap_array;

    void TrickleUp(int index);//插入新节点（末尾），接着向上渗透
    void TrickleDown(int index);//删除根节点（用最后一个节点补到根节点），接着向下渗透
};
#endif

#include<iostream>
using namespace std;
#include"Heap.h"
template<class T>
MaxHeap<T>::MaxHeap(int size = 10)
{
    if (size < 1)
        throw "max size must be >=1";
    max_size = size;
    current_size = 0;
    heap_array = new T[max_size];//int *a = new int[100];开辟一个大小为100的整型数组空间
}

template<class T>
bool MaxHeap<T>::IsEmpty()
{
    return current_size == 0;
}

template<class T>
MaxHeap<T>::~MaxHeap()
{
    delete[] heap_array;
}

template<class T>
void MaxHeap<T>::Push(const T& e)
{
    if (current_size == max_size) throw "max_array is full";
    heap_array[current_size] = e;
    TrickleUp(current_size++);
}

template<class T>
void MaxHeap<T>::TrickleUp(int index)//向上渗透，将新插入的元素向上调整到合适的位置
{
    T bottom = heap_array[index];
    int parent = (index - 1) / 2;
    while (index > 0 && heap_array[parent] < bottom)//注意这个地方自己第一次写成了heap_array[parent]<heap_array[index]
    {
        heap_array[index] = heap_array[parent];
        index = parent;
        parent = (parent - 1) / 2;
    }
    heap_array[index] = bottom;
}

template<class T>
void MaxHeap<T>::Pop()
{
    heap_array[0] = heap_array[--current_size];
    TrickleDown(0);
}

template<class T>
const T& MaxHeap<T>::Top()const
{
    return heap_array[0];
}

template<class T>
void MaxHeap<T>::TrickleDown(int index)//向下渗透，将当前位置的元素向下调整到合适位置，保持大根堆的性质
{
    T top = heap_array[index];
    int larger_child;
    while (index < current_size / 2)//这是完全二叉树的性质（最后一个非叶子节点的位置索引），好好体会
    {
        int lchild = 2 * index + 1;
        int rchild = 2 * (index + 1);
        if (rchild < current_size && heap_array[lchild] < heap_array[rchild])
            larger_child = rchild;
        else larger_child = lchild;
        if (top >= heap_array[index])//!!
            break;
        heap_array[index] = heap_array[larger_child];
        index = larger_child;
    }
    heap_array[index] = top;//这一句我第一次写时遗漏了
}

int main()
{
    MaxHeap<int> heap(20);
    cout << heap.IsEmpty() << endl;;
    heap.Push(7);
    heap.Push(24);
    heap.Push(9);
    cout << heap.Top() << endl;
    heap.Push(25);
    heap.Push(28);
    cout << heap.Top() << endl;
    heap.Pop();
    heap.Pop();
    cout << heap.Top() << endl;

    return 0;
}

 参考猎豹数据结构和算法讲解！