数据结构实现（优先级队列及堆排序类模板）

/*
优先级队列的堆实现（基于数组）
*/
#include "Array.cpp"

template <class DataType>
class CPriorityQueue
{
public:
CPriorityQueue();

CPriorityQueue(const Array<DataType> & arr);

void enqueue(const DataType & newElement);

bool dequeue(DataType & remElement);

bool isEmpty() const;

void makeEmpty();

private:
Array<DataType> elements;
int heapsize;
inline void heapify(int i);
};

#include "PriorityQueue.h"

template <class DataType>
CPriorityQueue<DataType>::CPriorityQueue() : elements(2),heapsize(0)
{

}

template <class DataType>
CPriorityQueue<DataType>::CPriorityQueue(const Array<DataType> & arr) : elements(arr),heapsize(arr.length())
{
for (int i=(heapsize-2)>>1;i>=0;i--)
{
heapify(i);
}

int trysize=2;
for (;trysize<elements.length();trysize <<=1)
{
;
}

if (trysize!=elements.length())
{
elements.ChangeSize(trysize);
}
}

template <class DataType>
void CPriorityQueue<DataType>::enqueue(const DataType & newElement)
{
if (heapsize==elements.length())
{
elements.ChangeSize(elements.length()<<1);
}

int i=heapsize;
for (;(i!=0) && newElement>elements[(i-1)>>1];i=(i-1)>>1)
{
elements[i]=elements[(i-1)>>1];
}

elements[i]=newElement;
heapsize++;
}

template <class DataType>
bool CPriorityQueue<DataType>::dequeue(DataType & remElement)
{
if (!heapsize)
{
return false;
}
remElement=elements[0];
heapsize--;
elements[0]=elements[heapsize];
heapify(0);

int trysize=elements.length();
while ((heapsize<=trysize>>2) && trysize > 2)
{
trysize >>=1;
}
if (trysize<elements.length())
{
try
{
elements.ChangeSize(trysize);
}
catch (...)
{

}
}
return true;
}

template <class DataType>
bool CPriorityQueue<DataType>::isEmpty() const
{
return !heapsize;
}

template <class DataType>
void CPriorityQueue<DataType>::makeEmpty()
{
heapsize=0;
try
{
elements.ChangeSize(2);
}
catch (...)
{
}
}

template <class DataType>
inline void CPriorityQueue<DataType>::heapify(int i)
{
int leftChild,rightChild,largest;
bool stop=false;

DataType temp=elements[i];
leftChild=(i <<1 )+1;
while (leftChild<heapsize && !stop)
{
rightChild=leftChild+1;
largest=(rightChild==heapsize) ? leftChild : ((elements[leftChild]>elements[rightChild]) ? leftChild : rightChild);
if (elements[largest]>temp)
{
elements[i]=elements[largest];
i=largest;
leftChild=(i << 1)+1;
}
else
{
stop=true;
}
}
elements[i]=temp;
}

#include "PriorityQueue.cpp"
#include <iostream>
using namespace std;

struct MyStruct
{
int id;
float amount;
bool operator>(const MyStruct & right)
{
return amount>right.amount;
}
};
/*
堆排序函数
*/
template <class DataType>
void heapSort(Array<DataType> & arr);
void main()
{
int num;
cin>>num;
Array<MyStruct> arr(num);
for (int i=0;i<arr.length();i++)
{
cin>>arr[i].id;
cin>>arr[i].amount;
}
heapSort(arr);
for (int j=0;j<arr.length();j++)
{
cout<<arr[j].id<<"/t"<<arr[j].amount<<endl;
}
}

template <class DataType>
void heapSort(Array<DataType> & arr)
{
CPriorityQueue<DataType> pq(arr);
for (int i=arr.length()-1;i>=0;i--)
{
pq.dequeue(arr[i]);
}
}