一个不错的模板Heap实现及Heap排序的实现

// MaxHeap.h

/*  MaxHeap: binary tree of which data of any node >=  either its child  */
/*  Using a dynamic array to store nodes, while i stands for a parent node,
    2i and 2i + 1 are its children  */

template<class T>
class MaxHeap
{
 public:
      MaxHeap (int maxHeapSize = 10);
      /*  heap points to array a when initializing, for preventing to delete the array a
           when calling ~MaxHeap (), make heap point nothing  */
      ~MaxHeap () { heap = 0; delete [] heap;}
      int size () const { return currentSize;}
      T max () {if (currentSize == 0) throw OutOfBounds ();
                      return heap[1];}
      MaxHeap<T>& insert (const T x);
      MaxHeap<T>& sift ();
      void initialize (T a[], int arraySize);
 private:
      int currentSize, maxSize;
      T *heap;
};

// implementation should be included in declaring file

template<class T>
MaxHeap<T>::MaxHeap (int maxHeapSize)
{
 maxSize = maxHeapSize;
 heap = new T[maxSize + 1]; // heap[1] as begining
 currentSize = 0;
}

/*  insert a new node with the valude of x  */
template<class T>
MaxHeap<T>& MaxHeap<T>::insert (const T x)
{
 int i;
    if (currentSize == maxSize) //throw NoMem();
  printf ("no memory!/n");
 else
 {
  // looking for the position of the new node from the new node
  // bottom-up
  i = ++currentSize;
  while (i != 1 && x > heap[i / 2])
  {
   heap[i] = heap[i / 2]; // exchange the position of the new node and its parent
   i /= 2; // up
  }
   
  heap[i] = x;
 }
    return *this;
}

/*  exchange the root and the last node, minish the currentSize by 1
    and adjust the structure of the whole tree  */
template<class T>
MaxHeap<T>& MaxHeap<T>::sift ()
{
    if (currentSize != 0)  //throw OutOfBounds ();
 {
  T y = heap[currentSize]; // the last node

  // allocate heap[1] (the max node) to the previous y position
  // then minish currentSize by 1
  heap[currentSize--] = heap[1];
   
  // looking for y's position from the root
  // top-down
  int i = 1, j = 2; // initialize i as the root, and j as left child
  while (j <= currentSize)
  {
   // select the bigger child of the node
   if (j < currentSize && heap[j + 1] > heap[j]) j++;
       
   if (y < heap[j])
   {
    heap[i] = heap[j]; // exchange the position of parent and child
    i = j; // down
    j *= 2;
   }
   else
    break;
  }
   
  heap[i] = y; // the new position of y
 }
    return *this;
}

template<class T>
void MaxHeap<T>::initialize (T a[], int arraySize)
{
    delete [] heap;
    heap = a;
    currentSize = 1; // a[1] as root
    maxSize = arraySize - 1; // a[0] doesn't count

 // in the beginning, a[1] as root, then insert the rest of array a one by one
 for (int i = 2; i < arraySize; i++)
     insert (a[i]);
}

// heapSort.cpp

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

template<class T>
/*  sorting a[1 : arraySize - 1]  */
void heapSort (T a[], int arraySize)
{
    MaxHeap<T> H(1);
    H.initialize (a, arraySize); // a[0] doesn't count
    for (int i = 1; i < arraySize; i++)
        H.sift ();
} 

int main ()
{
    int a[10] = {0,6,8,9,4,1,3,7,2,5};
    heapSort<int> (a, 10);
    for (int i = 1; i < 10; i++)
        cout << a[i] << " ";
   
 cin.get();
    return 0;
}