堆实例

#include <iostream>
using namespace std;
class A
{
 public:
     A(int *data, int len){}
 };
 
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);
 }
 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;
 }