经典算法学习：各种排序算法的模板类实现

参考：《大话数据结构》

对各种排序算法进行了模板类实现，备忘。

冒泡排序：

两两比较相邻记录的关键字，如果反序就交换，直到没有反序的记录为止。

简单选择排序：

通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i(1<=i<=n)个记录进行交换。

直接插入排序：

将一个记录插入到已经排好序的有序序列中，从而得到一个新的，记录数增加1的有序序列。

希尔排序：

将相距某个“增量”的记录组成一个子序列，保证子序列内分别进行直接插入排序后得到的结果是基本有序的。最后一次的增量必须为1。

堆排序：

将待排序列构造成一个最大堆，此时整个序列的最大值就是根结点。将根节点与末尾元素进行交换，则末尾元素是最大值。然后将n-1个元素重新构造最大堆，得到次大值，如此反复进行。

归并排序：

假设初始序列含有n个记录，可以看成n个有序的子序列，每个子序列长度为1，然后两两归并，得到长度为2或1的有序子序列；再两两归并，……，如此重复，直到得到一个长度为n的有序序列。

快速排序：

通过一趟排序将待排序列分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后分别再对这两部分进行排序，以达到整体有序。

各种排序算法的时间复杂度、辅助空间、稳定性：



下面是各种排序算法的模板类实现：

#pragma once
#ifndef SORT_H
#define SORT_H

template<typename T>
class Sort
{
private:
void Max_Heapify(T *array, int i, int heapSize);
void Merge(T *array,int left, int mid, int right);
void SubMerge(T *array, int left, int right);
void QuickSort(T *array, int left, int right);
public:
Sort();
~Sort();
void Bubble_Sort(T *array, const int length);
void Select_Sort(T *array, const int length);
void Insert_Sort(T *array, const int length);
void Shell_Sort(T *array, const int length);
void Heap_Sort(T *array, const int length);
void Merge_Sort(T *array, const int length);
void Quik_Sort(T *array, const int length);
};

#endif // !SORT_H

/*堆排序-构造最大堆*/
template<typename T>
inline void Sort<T>::Max_Heapify(T * array, int i, int heapSize)
{
int left = 2 * i + 1;
int right = 2 * i + 2;
int max = i;
if (left <= heapSize&&array[left] > array[i])
max = left;
if (right <= heapSize&&array[right] > array[max])
max = right;
if (max != i)
{
T temp = array[i];
array[i] = array[max];
array[max] = temp;
if (2 * max + 1 <= heapSize)
Max_Heapify(array, max, heapSize);
}
}

/*归并排序-两路排序合并*/
template<typename T>
inline void Sort<T>::Merge(T *array,int left,int mid,int right)
{
T *temp = new T[right - left + 1];//额外空间进行排序
int i = left;
int j = mid + 1;
int k = 0;
while (i <= mid&&j <= right)
{
if (array[i] < array[j])
{
temp[k++] = array[i++];
}
else
{
temp[k++] = array[j++];
}
}
while (i <= mid)
{
temp[k++] = array[i++];
}
while (j <= right)
{
temp[k++] = array[j++];
}
for (i = left, k = 0; i <= right;)
{
array[i++] = temp[k++];//将排序结果复制到原数组
}
delete []temp;
}

/*归并排序-分治*/
template<typename T>
inline void Sort<T>::SubMerge(T * array, int left, int right)
{
if (left < right)
{
int mid = (left + right) / 2;
subSort(array, left, mid);//左边有序
subSort(array, mid + 1, right);//后边有序
Merge(array, left, mid, right);//左右合并
}
}

/*快速排序-递归*/
template<typename T>
inline void Sort<T>::QuickSort(T * array, int left, int right)
{
while (left < right)
{
int i = left;
int j = right;
T pivot = array[i];//用区间的第一个记录作为基准，基准数在位置i上
while (i < j)//从区间的两端向中间扫描，直到i=j
{
while (i < j&&array[j] >= pivot)//从右向左找到小于基准的数
j--;
if(i<j)
array[i++] = array[j];
while (i < j&&array[i] <= pivot)//从左向右扫描找到大于基准的数
i++;
if(i<j)
array[j--] = array[i];
}
array[i] = pivot;//基准数的最终位置
QuickSort(array, left, i - 1);
left = i + 1;
}
}

template<typename T>
inline Sort<T>::Sort()
{
}

template<typename T>
inline Sort<T>::~Sort()
{
}

/*冒泡排序*/
template<typename T>
inline void Sort<T>::Bubble_Sort(T * array, const int length)
{
if (array == NULL)
{
throw invalid_argument("Array must not be empty.");
}
if (length <= 0)
return;
bool flag = true;//设置一个标记，如果flag=false，说明这一趟没有经过交换，已经排好序了
for (int i = 0; i < length - 1 && flag; i++)
{
flag = false;
for (int j = length - 2; j >= i; j--)
{
if (array[j] > array[j+1])
{
T temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
flag = true;
}
}
}
}

/*简单选择排序*/
template<typename T>
inline void Sort<T>::Select_Sort(T * array, const int length)
{
if (array == NULL)
{
throw invalid_argument("Array must not be empty.");
}
if (length <= 0)
return;
for (int i = 0; i < length-1; i++)
{
int min = i;//设置第i位为最小值，后面所有的数和它进行比较
for (int j = i + 1; j < length; j++)
{
if (array[j] < array[min])//如果后面有小于当前最小值的数，将这个数的下标赋给min
min = j;
}
if (min != i)//找到这一趟的实际最小值
{
T temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
}

/*直接插入排序*/
template<typename T>
inline void Sort<T>::Insert_Sort(T * array, const int length)
{
if (array == NULL)
throw invalid_argument("Array must not be empty.");
if (length <= 0)
return;
for (int i = 1; i < length; i++)
{
T temp = array[i];
int j = i - 1;
while (j >= 0 && array[j] > temp)
{
array[j + 1] = array[j];
j--;
}
array[j + 1] = temp;
}
}

/*希尔排序*/
template<typename T>
inline void Sort<T>::Shell_Sort(T * array, const int length)
{
if (array == NULL)
throw invalid_argument("Array must not be empty.");
if (length <= 0)
return;

int increment = length / 2;//设置增量
while (increment)
{
T temp;
for (int i = increment; i < length; i++)
{
temp = array[i];
int j = i;
while (j >= increment&&temp < array[j - increment])
{
array[j] = array[j - increment];
j -= increment;
}
array[j] = temp;
}
increment /= 2;
}

}

/*堆排序*/
template<typename T>
inline void Sort<T>::Heap_Sort(T * array, const int length)
{
if (array == NULL)
{
throw invalid_argument("Array must not be empty.");
}
if (length <= 0)
return;
for (int i = length / 2-1; i >= 0; i--)
{
Max_Heapify(array, i, length - 1);//构造一个最大堆
}
for (int i = length -1; i >= 0; i--)//将堆顶元素和末尾元素交换，剩下的元素再构造最大堆
{
T temp = array[0];
array[0] = array[i];
array[i] = temp;
Max_Heapify(array, 0, i - 1);
}
}

/*归并排序*/
template<typename T>
inline void Sort<T>::Merge_Sort(T * array, const int length)
{
/*T* sorted = (T*)malloc(length * sizeof(T));
int k = 0;
while (k < length - 1)
{
Merge_Pass(array, sorted, k, length);
k = 2 * k;
Merge_Pass(sorted, array, k, length);
k = 2 * k;
}*/
if (array == NULL)
{
throw invalid_argument("Array must not be empty.");
}
if (length <= 0)
return;
subSort(array, 0, length - 1);
}

/*快速排序*/
template<typename T>
inline void Sort<T>::Quik_Sort(T * array, const int length)
{
if (array == NULL)
throw invalid_argument("Array must not be empty.");
if (length <= 0)
return;
QuickSort(array, 0, length - 1);
}

如果不足，欢迎指正！