c++模板类实现算法堆排序

#include <vector>								//利用vector容器实现堆

template<class T>
class HeapSort
{
public:
HeapSort( )									//默认构造函数
{}

HeapSort( T* a, size_t n )					//构建堆			//假设需要升排列 ，我们构建大堆，  每次将最大的元素与最后一个元素交换后， 最大的就在后面， 将这个元素，最大元素忽视(假设数组里已经没有这个元素)再建堆， 重复之前操作， 完成升序
{
_a.reserve( n );

for ( size_t i = 0; i < n; ++i )		//先构建一颗树
{
_a.push_back( a[i] );
}

AdjustDown( _a.size( ) );				//用向下调整算法构建大堆
Sort( );								//排序
//for ( size_t k = _a.size( ); k > 2;  --k )//只有一个元素时就不需要排序了
//{
//	swap( _a[0], _a[k - 1] );

//	for ( int y = (k - 3) / 2; y >= 0; --y )//此时当堆里面只有 k-1 个元素
//	{
//		AdjustDown( y, k - 1 );			//必须自己传此时堆元素个数， 不能用_a.size( )否则程序会出错
//	}
//}

//if ( _a[0] < _a[1] )
//{
//	swap( _a[0], _a[1] );
//}
}

void AdjustDown( size_t size )				//堆中元素个数
{
for ( int i = (size - 2) / 2; i >= 0; --i )//向下调整算法构建大堆   int.   凡是条件为>=0,  则不能用 size_t类型，否则会死循环
{
_AdjustDown( i, size );
}
}

void Print( )
{
for ( size_t i = 0; i < _a.size( ); ++i )
{
cout << _a[i] << " ";
}
}

void _AdjustDown( size_t parent, size_t size )
{
size_t child;
child = parent * 2 + 1;					//必须是左孩子  左孩子存在右孩子可能存在， 左孩子不存在，右孩子肯定不存在

while ( child < size )
{
if ( (size != child + 1) && (_a[child + 1] > _a[child]) )//右孩子存在 再判断后面条件
{
++child;						//此时child为孩子中最大值下标
}

if ( _a[child] > _a[parent] )
{
swap( _a[child], _a[parent] );

parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}

void Sort( )								//死循环了， 也往 size_t类型那想想
{
for ( size_t i = _a.size( ); i > 1; --i )//只有一个元素就不需要排序了   每次都把最后一个元素除外，利用原元素数量 - 1再调整一次
{
AdjustDown( i - 1 );

swap( _a[0], _a[i - 1] );			//如果这里两个顺序颠倒，可以少调整一次，但是 AdjustDown中i就不能为size_t类型，而要为int
}
}

private:
vector<T> _a;
};												//先写;

#include <iostream>
#include <windows.h>
using namespace std;

#include "HeapSort.h"

void test( );

int main( )
{

int a [] = {10,11, 13, 12, 16, 18, 15, 17, 14, 19};

HeapSort<int> t1( a, sizeof(a) / sizeof(a[0]) );

t1.Print( );

system( "pause" );
return 0;

}