排序算法之希尔排序和堆排序

希尔排序简述：

希尔排序可以看作是直接插入排序的一种优化，即把一个数插入一个有序表，不过希尔排序多了一个默认的增量，把一个序列分成若干个增量大小的增量序列，然后在子序列直接进行直接插入排序，每次都使较小的数排到靠前的子序列里面，增量不断减小，子序列也不断缩小，最终使整个表有序。

排序前的准备：

准备了一个默认的顺序表

#define MAXSIZE 10
//顺序表结构
template <class T>
struct SqList
{
T s[MAXSIZE + 1] = { NULL, 98, 24, 55, 81, 32, 77, 48, 60, 14, 8 }; //数组s，s[0]用作哨兵
int length = MAXSIZE; //s长度
void PrintArray();
};
typedef SqList<int> SList;

//交换l中的数组中下标为i和j的值
void Swap(SList *L, int i, int j)
{
int temp = L->s[i];
L->s[i] = L->s[j];
L->s[j] = temp;
}
希尔排序实现：

这里的length为10，增量选择为length/3 +1=4。

增量的选择可以是任意小于length的一个数，但最后要等于1，即能进行最后一次直接插入排序即可。

//希尔排序
//设置一个增量，来进行直接插入排序。
void ShellSort(SList *L)
{
int i, j;
int increment = L->length; //增量
do
{
increment = increment / 3 + 1; //增量
for (i = increment+1; i <= L->length; i++) //遍历从第一个增量序列的后一个元素开始
{
if (L->s[i] < L->s[i-increment]) //增量序列后一个元素小于增量序列的第一个元素
{
L->s[0] = L->s[i]; //把s[0]哨兵赋值为s[i]
for (j = i-increment; j>0 && L->s[0]<L->s[j] ;j-= increment)
{//只循环一次
L->s[j + increment] = L->s[j]; //将增量序列后一个元素赋值为增量序列的第一个元素
}
L->s[j+increment] = L->s[0]; //最后改变增量序列的第一个元素为哨兵值
}
}
} while (increment > 1); //当增量小于等于1时终止循环
}
希尔排序时间复杂度：

希尔排序的时间复杂度和增量的选取有关系，并不是完全相同的。

最优情况下的时间复杂度为O(n^1.3)；

最坏情况下的时间复杂度为O(n^2);

堆排序简述：

堆排序利用了完全二叉树的性质来进行，堆排序把一个顺序表先构造成一个大顶堆，大顶堆即所有父节点比子节点大的一个完全二叉树，构造成大顶堆后，把根节点(即当前最大值)和最后的元素交换，并继续把长度减一的剩余顺序表构造成大顶堆，如此循环。

堆排序实现：

这里碰到了一个问题是如何将顺序表构造成大顶堆？

代码如下：

//构造成大顶堆
void HeapAdjust(SList *L,int i,int length)
{
int temp, j;
temp = L->s[i]; //临时变量赋值为当前父节点，用于后续的比较
for (j = 2 * i; j <= length; j *= 2) //j=2*i指向左孩子节点
{
if (L->s[j]<L->s[j+1] && j<length) //如果左孩子比右孩子小，则j指向右孩子.j<length说明j不是最后节点
{
++j;
}
if (temp>L->s[j]) //如果一开始的父节点比两个子节点都大，break
{
break;
}
L->s[i] = L->s[j]; //父节点比子节点小，把父节点赋值为两个孩子中较大的一个
i = j; //父节点指向子节点中较大的一个继续循环
}
L->s[i] = temp; //把子节点较大的一个赋值为父节点
}堆排序如下：
//堆排序
//将无序数列构造成大顶堆，把根节点和层序遍历最后节点互换，然后把剩下元素继续构造大顶堆
void HeapSort(SList *L)
{
int i;
for (i = L->length / 2; i > 0; i--) //i=Length/2 因为完全二叉树的父节点数量为叶子节点的一半
{
HeapAdjust(L, i, L->length); //将整个序列构造成大顶堆
}
for (i = L->length; i > 1; i--)
{
Swap(L, 1, i); //把根节点和最后一位互换
HeapAdjust(L, 1, i - 1); //继续构造大顶堆
}
}程序首先从完全二叉树的父节点开始遍历到根节点(即(length/2)个父节点)，将这些父节点下面的小子树分别构造成大顶堆，最终得到一个完全的大顶堆；
然后从尾到头开始遍历，把最大的数和最后节点交换，并继续遍历除最大节点意外剩余节点，最终即得到一个从小到大的有序表。

堆排序时间复杂度:

构建一个大顶堆从最下层最右边的父节点开始遍历，进行交换，构造堆需要的时间复杂度为O(n);

而重建堆需要的时间复杂度为O(nlogn),所以整体的堆排序时间复杂度为O(nlogn)。

堆排序不适合元素数量较少的情况。