简单模板排序的实现（回顾排序）

/*
用模板实现排序的类Sort
简单的把几个常用的排序方法加到Sort类里面
其中包含冒泡排序，选择排序，快速排序，归并排序
*/
template<class T>
class Sort{
public:
// 冒泡排序
static void BubbleSort(T* array, int size);
// 选择排序
static void SelectSort(T* array, int size);
// 快速排序
static void QuickSort(T* array, int left, int right);
// 归并排序
static void Merge(T* array, int left, int mid, int right);
static void MergeSort(T* array, int left, int right);
private:
// 交换元素函数
static void Swap(T* array, int a, int b);
};

// 交换数组里面的元素
template<class T>
void Sort<T>::Swap(T* array, int a, int b)
{
T temp = array[a];
array[a] = array[b];
array[b] = temp;
}

// 冒泡排序
template<class T>
void Sort<T>::BubbleSort(T* array, int size)
{
for (int i = 0; i < size; i++)
{
for (int j = 1; j < size; j++)
{
if (array[j] < array[j - 1])
{
Swap(array, j, j - 1);
}
}
}
}

// 选择排序
template<class T>
void Sort<T>::SelectSort(T* array, int size)
{
int minIndex = 0;
for (int i = 0; i < size; i++)
{
minIndex = i;
for (int j = i + 1; j < size; j++)
{
if (array[minIndex] > array[j])
{
minIndex = j;
}
}
if (minIndex != i)
{
Swap(array, i, minIndex);
}
}
}

// 快速排序
template<class T>
void Sort<T>::QuickSort(T* array, int left, int right)
{
if (left < right)
{
int i = left - 1, j = right + 1;
T mid = array[(left + right) / 2];
while (true)
{
while (array[++i] < mid);
while (array[--j] > mid);
if (i >= j)
{
break;
}
Swap(array, i, j);
}
QuickSort(array, left, i - 1);
QuickSort(array, j + 1, right);
}
}

/*
方式是先两两排序，组合，再排序
例如 54 26 35 46 85 95 68
先54-26 35-46 85-95 68
再26-54 - 35-46   68 - 85-95
再26-35-46-54 - 68-85-95 最后整合
*/
// 归并组合
template<class T>
void Sort<T>::Merge(T* array, int left, int mid, int right)
{
T* temp = new T[right - left + 1];
int i = left, j = mid + 1, m = 0;
while (i <= mid && j <= right)
{
if (array[i] < array[j])
{
temp[m++] = array[i++];
}else {
temp[m++] = array[j++];
}
}
while (i <= mid)
{
temp[m++] = array[i++];
}
while(j <= right)
{
temp[m++] = array[j++];
}
for (int n = left, m = 0; n <= right; n++, m++)
{
array
= temp[m];
}
delete temp;
}

// 归并排序
template<class T>
void Sort<T>::MergeSort(T* array, int left, int right)
{
if (left < right)
{
int mid = (left + right) / 2;
MergeSort(array, left, mid);
MergeSort(array, mid + 1, right);
Merge(array, left, mid, right);
}
}

void main()
{
int number[] = {5, 65, 56, 89, 797, 54, 68, 79, 103};
/*打印方法没有写*/
//printArray(number, sizeof(number) / sizeof(int));
/*换排序算法*/
//Sort<int>::SelectSort(number, sizeof(number) / sizeof(int));
//Sort<int>::MergeSort(number, 0, sizeof(number) / sizeof(int) - 1);
//printArray(number, sizeof(number) / sizeof(int));
}