四种排序为 折半插入，希尔排序，快排，堆排序
快排比较重要，前两个学习时候忽略掉了，堆排序以前一直以为比较复杂，现在看来感觉还可以，不过我坚信手写一遍代码是个好习惯。
首先是折半插入(复杂度O(n^2))：
折半插入主要就是对于插入排序中，查询插入点进行了改良，上代码：
void BInsertSort(SqList &L){
for(i=2;i<=L.length;++i){
L.r[0] = L.r[1];
low = 1; high = i-1;
while(low < high){
m = (low+high)/2;
if(LT(L.r[0].key, L.r[m].key)) high = m-1;
else low = m+1;
}//while
for(j = i-1; j>=high+1;--j) L.r[j++] = L.r[j];
L.r[high+1] = L.r[0];
}//for
}//BInsertSort
然后是希尔排序(复杂度O(n^3/2))：
希尔排序是对于插入排序的另一种改进，主要思路是，插入排序，较优情况发生在插入串基本有序，此时插入所需要移动的元素就会较少。上代码：
void ShellInsert(SqList &L, int dk){
for(i = dk+1; i<= L.length; ++i){
if(LT(L.r[i].key, L.r[i-dk].key)){
L.r[0] = L.r[i];
for(j=i-dk; j>0&<(L.r[0].key,L.r[j].key)); j-=dk;
L.r[j+dk] = L.r[j];
L.r[j+dk] = L.r[0];
}//if
}//for
}//ShellInsert
void ShellSort(SqList &L, int dlta[], int t){
for(k=0; k<t; k++)
SHellInsert(L, dlta[k]);
}
还需要说一下就是，dlta[]，即增量序列的，注意事项，应使增量序列中的值没有除1之外的公因子，并且最后一个增量值必须等于1
接着是快速排序(复杂度O(nlogn)，最坏时为O(n^2))：
快排是很经典的排序算法了，他是一种优化了的冒泡排序，太熟悉了，直接放代码：
int Partition(SqList &L, int low, int high){
L.r[0] = L.r[low];
pivotkey = L.r[low].key;
while(low < high){
while(low < high && L.r[high].key > pivotkey) --high;
L.r[low] = L.r[high];
while(low < high && L.r[low].key <= pivotkey) ++ low;
L.r[high] = L.r[low];
}//while
L.r[low] = L.r[0];
return low;
}// Partition
void QSort (SqList &L, int low, int high){
if(low < high){
prvotloc = Partition(L, low, high);
QSort(L, low, pivotloc - 1);
QSort(L, pivotloc + 1, high);
}
}//QSort
void QuickSort(SqList &L){
QSort(L, 1, L.length);
}
最后是堆排序(复杂度O(nlogn)，最坏时也为O(nlogn))：
堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
首先解释下堆：堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
首先我们来看一下书中的代码
typedef SqList HeapType;
void HeadAdjust(HeadType &H, int s, int m){
rc = H.r[s];
for (j = 2*s; j<=m; j *= 2){//自上而下调整树
if(j<m && LT(H.r[j].key, H.r[j+1].key)) ++j;//这里就是看取左子节点还是右子节点
if(!LT(rc.key, H.r[j].key)) break;//子节点没有根节点大的时候，不需要调整
H.r[s] = H.r[j]; s = j;//注意这个s=j，调整根节点放置位置
}//for
H.r[s] = rc;
}//HeapAdjust
void HeapSort(HeapType &H){
for(i = H.length/2; i>0; --i ){
HeapAdjust(H, i, H.length);
}
for(i = H.length; i>1; --i){
H.r[1]<-->H.r[i];
HeapAdjust(H,1,i-1);
}
}//HeapSort
emm，刚开始看没太看明白，手抄了一遍，又看了两遍，终于通了，跟网上一位同行的代码，对比之下感觉很是优雅，不过相对的，代码没有那么直观易懂，下面贴一下看到的另一份代码。
#include<stdio.h>
int c=0;
/*heapadjust()函数的功能是实现从a[m]到a[n]的数据进行调整，使其满足大顶堆的特性*/
/*a[]是待处理的数组，m是起始坐标， n是终止坐标*/
void heapadjust(int a[], int m, int n)
{
int i, temp;
temp=a[m];
for(i=2*m;i<=n;i*=2)//从m的左孩子开始
{
if(i+1<=n && a[i]<a[i+1])//如果左孩子小于右孩子，则将i++，这样i的值就是最大孩子的下标值
{
i++;
}
if(a[i]<temp)//如果最大的孩子小于temp，则不做任何操作，退出循环；否则交换a[m]和a[i]的值，将最大值放到a[i]处
{
break;
}
a[m]=a[i];
m=i;
}
a[m]=temp;
}
void crtheap(int a[], int n)//初始化创建一个大顶堆
{
int i;
for(i=n/2; i>0; i--)//n/2为最后一个双亲节点，依次向前建立大顶堆
{
heapadjust(a, i, n);
}
}
/*swap()函数的作用是将a[i]和a[j]互换*/
void swap(int a[], int i, int j)
{
int temp;
temp=a[i];
a[i]=a[j];
a[j]=temp;
c++;
}
void heapsort(int a[], int n)
{
int i;
crtheap(a, n);
for(i=n; i>1; i--)
{
swap(a, 1, i);//将第一个数，也就是从a[1]到a[i]中的最大的数，放到a[i]的位置
heapadjust(a, 1, i-1);//对剩下的a[1]到a[i-1]，再次进行堆排序，选出最大的值，放到a[1]的位置
}
}
int main(void)
{
int i;
int a[10]={-1,5,2,6,0,3,9,1,7,4};
printf("排序前：");
for(i=1;i<10;i++)
{
printf("%d",a[i]);
}
heapsort(a, 9);
printf("\n\n共交换数据%d次\n\n", c);
printf("排序后：");
for(i=1;i<10;i++)
{
printf("%d",a[i]);
}
printf("\n\n\n");
return 0;
}
书上的代码，更加简洁优美，只使用了一个缓存位置，适合装个*和有高追求的选手，而网上这份呢更加通俗易懂，如何选择，是各位的自由了，这也正是代码的魅力之一啊。
（引用代码链接：https://blog.csdn.net/kuweicai/article/details/54710409）
下面是几种排序算法的比较
排序算法比较
几点说明：
-
从平均时间性能而言，快排最佳，时间最省，但最坏情况下不如堆排序和归并排序，后两者相比，n较大时，归并较堆排序更省时间，但所需辅助存储量也最多。
-
直接插入排序最为简单，当序列中记录基本有序时，他是最佳的算法，所以常与其他算法共用。
-
基数排序时间复杂度也可以写成O(d*n)，它最适用于n很大，而且关键字小的序列。若关键字很大，而序列中大多数记录的‘最高位关键字’均不同，则亦可先按 ‘最高位关键字’ 不同将序列分成若干小的序列，而后进行直接插入排序。
-
从方法稳定性来看，基数排序是稳定的内排算法，所有时间复杂度为O(n^2)的简单排序都是稳定的，归并排序也是稳定的，但是快排，堆排序和希尔排序则是不稳定的。一般来说，排序过程中的‘比较’是在“相邻的两个记录关键字”间进行的排序算法是稳定的。
网友评论