堆的结构原理以及堆排序的实现

1.不多说了，我想直接上代码。

#pragma once
#include<cstdio>
#include<iostream>
using namespace std;
template<class T>
class MinHeap
{
private:
	//申请堆空间
	T *_minHeap = NULL;
	int CurSize, _maxSize;
public:
	MinHeap() {};
	MinHeap(int maxSize);
	MinHeap(MinHeap &h);
	~MinHeap() {delete[]_minHeap;}
	//获取整个最小堆的头部指针
	T * getMinHeap() {return _minHeap;}
	//判断堆是不是空的
	bool isEmpty() {return CurSize == -1;}
	//数组里面加入元素
	bool add(const T x);
	bool isFull();
	//堆进行向下调整
	void adjustDown(int index);
	//队进行向上调整
	void adjustUp(int index);
	//建堆运算
	void createMinHeap();
	//插入
	//删除
	bool del( T&x);
	//堆排序
	int SortByHeap();
};
template<class T>
int MinHeap<T>:: SortByHeap()
{
	int num = 1;
	while (CurSize>=0)
	{
		int tem;
		this->del(tem);
		cout << tem << " ";
		num++;
		if (num % 15 == 0)cout << endl;
	}
	return 0;
}
template<class T>
bool MinHeap<T>::del( T&x)
{
	if (CurSize == -1)return false;
	else
	{
		x = _minHeap[0];
		_minHeap[0] = _minHeap[CurSize--];
		adjustDown(0);
		return true;
	}
}
template<class T>
bool MinHeap<T>::add(T x) {
	if (isFull()) {
		return false;
	}
	CurSize++;
	_minHeap[CurSize] = x;
	return true;
}
template <class T>
MinHeap<T>::MinHeap(int maxSize)
{
	_maxSize = maxSize;
	_minHeap = new T[_maxSize];
	CurSize = -1;
}
template<class T>
MinHeap<T>::MinHeap(MinHeap&h)
{
	CurSize = h.CurSize;
	_maxSize = h._maxSize;
	_minHeap = new T[_maxSize];
	for (int i = 0; i < _maxSize; i++) {
		*_minHeap[i] = *h._minHeap[i];
	}
}
template<class T>
void MinHeap<T>::createMinHeap()
{
	if (isEmpty()) {
		return;
	}
	for (int i = (CurSize - 1) / 2; i > -1; i--) 
	{
		adjustDown(i);
	}
}
template<class T>
bool MinHeap<T>::isFull()
{
	return CurSize == _maxSize;
}
template<class T>
void MinHeap<T>::adjustDown(int index) {
	if (isEmpty()) {
		return;
	}
	while (index < CurSize)
	{
		T temp = _minHeap[index];
		int oneC = 2 * index + 1;
		int twoC = 2 * index + 2;
		if (oneC == CurSize) 
		{
			_minHeap[index] = _minHeap[oneC];
			_minHeap[oneC] = temp;
			return;
		}
		if (twoC > CurSize) 
		{
			return;
		}
		if (_minHeap[oneC] <= _minHeap[twoC]) 
		{
			if (temp > _minHeap[oneC]) {
				_minHeap[index] = _minHeap[oneC];
				_minHeap[oneC] = temp;
				index = oneC;
			}
			else
			{
				index = CurSize;
			}
		}
		else
		{
			if (temp > _minHeap[twoC]) {
				_minHeap[index] = _minHeap[twoC];
				_minHeap[twoC] = temp;
				index = twoC;
			}
			else
			{
				index = CurSize;
			}
		}
	}
}
template<class T>
void MinHeap<T>::adjustUp(int index) {
	if (index > CurSize) 
	{
		return;
	}
	while (index > -1)
	{
		T temp = _minHeap[index];
		int father = (index - 1) / 2;
		if (father >= 0) 
		{
			if (temp < _minHeap[father]) {
				_minHeap[index] = _minHeap[father];
				_minHeap[father] = temp;
				index = father;
			}
			else 
			{
				index = -1;
			}
		}
		else
		{
			index = -1;
		}
	}
}