堆的C++代码实现

其实堆这个概念很早就知道了，也大概能说出来它的用途，但是真要是让用代码去实现的话，就没有看起来那么简单了，切忌不可眼高手低。

堆的基本操作：插入一个元素，删除最大的元素也就是根节点，其他堆调整操作都是为这两个操作服务的。堆分为最大堆和最小堆，这里实现一个最大堆。还有就是一个在建堆的时候很有用的性质：一个大小为N的堆，其叶子节点的下标是N/2+1,N/2+2.......n. 这样就可以少循环N/2次，因为叶子节点本身就是最大堆，不需要调整。

template<class T> class MaxHeap{
 private:
    T *datas;
    int MaxSize;
    int currentSize;
    void KeepHeap(int root);
    bool del;
 public:
    MaxHeap(int MaxSize);
    MaxHeap(T *datas, int length);
    ~MaxHeap();
    bool Insert(T data);
    T GetMax();
    void RemoveMax();
    void PrintHeap(){
        for (int i=1; i<=currentSize; i++)
        {
            cout << datas[i] << "   ";
        }
        cout << endl;
    }
    int GetCurrentSize()
    {
        return currentSize;
    }
    //void BuildMaxHeap(T *datas);
 };

template <class T> MaxHeap<T>::MaxHeap(T *datas, int length)
{
    this->datas = datas;
    currentSize = length;
    MaxSize = currentSize;
    for (int i=currentSize/2; i>0; i--)
    {
        KeepHeap(i);
    }
    del = false;
}

template<class T> MaxHeap<T>::MaxHeap(int MaxSize)
{
    this->MaxSize = MaxSize;
    datas = new T[this->MaxSize+1];
    this->currentSize = 0;
    del = true;
}

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

template<class T> bool  MaxHeap<T>::Insert(T data)
{
    if (currentSize+1 > MaxSize)
    {
        return false;
    }
    datas[++currentSize] = data;
    int index = currentSize;
    int temp = (index)/2;
    while (temp>=1)
    {
        if (datas[temp]<data)
        {
            datas[index] = datas[temp];
            index = temp;
            temp = temp/2;
        }else{
            break;
        }
    }
    datas[index] = data;
    return true;
}

template<class T> T MaxHeap<T>::GetMax()
{
    return datas[1];
}

template<class T> void MaxHeap<T>::KeepHeap(int root)
{
    int temp = datas[root];
    while (root*2<=currentSize)
    {
        int child = root*2;
        if (child+1<=currentSize && datas[child] < datas[child+1])
        {
            child++;
        }
        if (temp > datas[child])
        {
            break;
        }else
        {
            datas[root] = datas[child];
        }
        root = child;
    }
    datas[root] = temp;
}

template<class T> void MaxHeap<T>::RemoveMax()
{
    int temp = datas[1];
    datas[1] = datas[currentSize];
    datas[currentSize] = temp;
    currentSize--;
    KeepHeap(1);
}

堆的使用：堆最直接的使用就是用来排序；还有就是找当K比较小能放进内存的时候，用来找前K个最小数（用最大堆）或者K个最大数（用最大堆）

#include "stdafx.h"
#include <iostream>
#include "MaxHeap.h"

 using namespace std;
class A{
public:
    A(int *data, int len){}
};

void MinK(int *data, int length, int k)
{
    MaxHeap<int> heap(length);
    for (int i=1; i<length; i++)
    {
        if (k>heap.GetCurrentSize())
        {
            heap.Insert(data[i]);
        }else{
            if (data[i]<heap.GetMax())
            {
                heap.RemoveMax();
                heap.Insert(data[i]);
            }
        }
    }
    heap.PrintHeap();
}

int main(int argc, char* argv[])
{
//     MaxHeap<int> h(4);
//     h.Insert(1);
//     h.Insert(2);
//     h.Insert(3);
    int data[] = {-1,15,24,3,8,7,6,5,7};
    int len = sizeof(data)/sizeof(int);
    MaxHeap<int> h(data, len-1);
    for (int i=1; i<len; i++)
    {
        h.RemoveMax();
    }
    for (i=1; i<len; i++)
        cout << data[i] << " ";
    cout << endl;

    MinK(data,len,3);
    return 0;
}