堆排序

    今天，我们一起用C++实现堆排序，目的是熟练C++的语法，具体代码如下。

Data.h具体内容如下：

template<typename Type> class Element{
public:
	Type GetKey(){
		return key;
	}

	void SetKey(Type item){
		key = item;
	}

public:
	Element<Type>& operator =(Element<Type> copy){
		key = copy.key;
		return *this;
	}

	bool operator ==(Element<Type> item){
		return this->key == item.key;
	}

	bool operator !=(Element<Type> item){
		return this->key != item.key;
	}

	bool operator <(Element<Type> item){
		return this->key < item.key;
	}

	bool operator >(Element<Type> item){
		return this->key > item.key;
	}

	bool operator >=(Element<Type> item){
		return this->key >= item.key;
	}

	bool operator <=(Element<Type> item){
		return this->key <= item.key;
	}


private:
	Type key;
};

template<typename Type> class Sort;
template<typename Type> class DataList{
public:
	friend class Sort < Type > ;
	DataList(int size = m_nDefaultSize) : m_nMaxSize(size), m_ncurrentsize(0){
		m_pvector = new Element<Type>[size];
	}

	DataList(Type *data, int size);

	bool Insert(Type item);
	~DataList(){
		delete[] m_pvector;
	}

	int Size(){
		return this->m_ncurrentsize;
	}
	void Swap(Element<Type> &left, Element<Type> &right){
		Element<Type> temp = left;
		left = right;
		right = temp;
	}

	void Print();
private:
	static const int m_nDefaultSize = 10;
	Element<Type> *m_pvector;
	const int m_nMaxSize;
	int m_ncurrentsize;
};

template<typename Type> DataList<Type>::DataList(Type *data, int size)
	: m_nMaxSize(size > m_nDefaultSize ? size : m_nDefaultSize), m_ncurrentsize(0){
	this->m_pvector = new Element<Type>[size];
	for (int i = 0; i < size; i++){
		this->m_pvector[i].SetKey(data[i]);
	}
	this->m_ncurrentsize += size;

}

template<typename Type> bool DataList<Type>::Insert(Type item){
	if (this->m_ncurrentsize == this->m_nMaxSize){
		cerr << "The list is full!" << endl;
		return 0;
	}
	this->m_pvector[this->m_ncurrentsize++].SetKey(item);
}

template<typename Type> void DataList<Type>::Print(){
	cout << "The list is:";
	for (int i = 0; i < this->m_ncurrentsize; i++){
		cout << " " << this->m_pvector[i].GetKey();
	}
}

LinkQueue.h具体内容如下：

#include "QueueNode.h"

template<typename Type> class LinkQueue{
public:
	LinkQueue() :m_prear(NULL), m_pfront(NULL){}
	~LinkQueue(){
		MakeEmpty();
	}
	void Append(const Type item);
	Type Delete();
	Type GetFront();
	void MakeEmpty();
	bool IsEmpty() const{
		return m_pfront == NULL;
	}
	void Print();

private:
	QueueNode<Type> *m_prear, *m_pfront;
};

template<typename Type> void LinkQueue<Type>::MakeEmpty(){
	QueueNode<Type> *pdel;
	while (m_pfront){
		pdel = m_pfront;
		m_pfront = m_pfront->m_pnext;
		delete pdel;
	}
}

template<typename Type> void LinkQueue<Type>::Append(const Type item){
	if (m_pfront == NULL){
		m_pfront = m_prear = new QueueNode<Type>(item);
	}
	else{
		m_prear = m_prear->m_pnext = new QueueNode<Type>(item);
	}
}

template<typename Type> Type LinkQueue<Type>::Delete(){
	if (IsEmpty()){
		cout << "There is no element!" << endl;
		exit(1);
	}
	QueueNode<Type> *pdel = m_pfront;
	Type temp = m_pfront->m_data;
	m_pfront = m_pfront->m_pnext;
	delete pdel;
	return temp;
}

template<typename Type> Type LinkQueue<Type>::GetFront(){
	if (IsEmpty()){
		cout << "There is no element!" << endl;
		exit(1);
	}
	return m_pfront->m_data;
}

template<typename Type> void LinkQueue<Type>::Print(){
	QueueNode<Type> *pmove = m_pfront;
	cout << "front";
	while (pmove){
		cout << "--->" << pmove->m_data;
		pmove = pmove->m_pnext;
	}
	cout << "--->rear" << endl << endl << endl;
}

QueueNode.h具体内容如下：

template<typename Type> class LinkQueue;

template<typename Type>
class QueueNode
{
private:
	friend class LinkQueue < Type > ;
	QueueNode(const Type item, QueueNode<Type> *next = NULL)
		:m_data(item), m_pnext(next){}
private:
	Type m_data;
	QueueNode<Type> *m_pnext;
};

Sort.h具体内容如下：

#include "Data.h"
#include "LinkQueue.h"

template<typename Type> class Sort{
public:	
	void HeapSort(DataList<Type> &list);
private:	
	void HeapAdjust(DataList<Type> &list, const int start, const int end);
};
template<typename Type>
void Sort<Type>::HeapAdjust(DataList<Type> &list, const int start, const int end){
	int current = start, child = 2 * current + 1;
	Element<Type> temp = list.m_pvector[start];
	while (child <= end){
		if (child < end && list.m_pvector[child] < list.m_pvector[child + 1]){
			child++;
		}
		if (temp >= list.m_pvector[child]){
			break;
		}
		else {
			list.m_pvector[current] = list.m_pvector[child];
			current = child;
			child = 2 * current + 1;
		}
	}
	list.m_pvector[current] = temp;
}

template<typename Type>
void Sort<Type>::HeapSort(DataList<Type> &list){
	for (int i = (list.m_ncurrentsize - 2) / 2; i >= 0; i--){
		HeapAdjust(list, i, list.m_ncurrentsize - 1);
	}

	for (int i = list.m_ncurrentsize - 1; i >= 1; i--){
		list.Swap(list.m_pvector[0], list.m_pvector[i]);
		HeapAdjust(list, 0, i - 1);
	}
}

main.cpp具体内容如下：

#include <iostream>
using namespace std;
#include "Sort.h"
int main()
{
	int init[15] = { 1, 3, 5, 7, 4, 2, 8, 0, 6, 9, 29, 13, 25, 11, 32 };
	DataList<int> data(init, 15);
	Sort<int> sort;
	data.Print();
	cout << endl << endl << endl;	
	sort.HeapSort(data);	
	data.Print();
	cin.get();
	return 0;
}

运行效果如图1所示：

图1 运行效果