1.4 堆排序

void SIFT(table t[],int len ,int k){table t1;int i,j;i = k;j = 2 * i;t1 = t[i];/*t1 是 t[i]的左节点*/while(j < len){if((j < (len -1)) && (t[j].key < t[j+1].key ))j++;  if(t1.key < t[j].key)  // child 指向Ri的左、右子女中排序码较大的结点{t[i] = t[j];i = j;j = 2 * i;/*进入下一层继续调整*/}elsebreak;}t[i] = t1;// 将记录Ri放入正确位置}

1.4.3堆排序算法

void heapSort(table t[],int len){  int i;  table t1;  /*建立初始堆*/  for(i = len/2 -1;i >= 0; i--){  SIFT(t,len,i);  }  /* 进行n-1趟堆排序*/  for(i = len -1;i>0;i--){  /* 堆顶和最后一个互换 */  t1 = t[0];  t[0] = t[i];  t[i] = t1;  SIFT(t,i,0);// 从R0到Ri-1重建堆  }
}  

1.5 冒泡排序

冒泡排序，若按升序进行，则小的浮起，大的沉底；
第一趟：第1个与第2个记录比较，逆序则交换；第2个与第3个记录比较，逆序则交换；直到对最后两个记录比较、交换完成；一趟排序完成，会有一个极值存储到最终位置。

第二趟：缩小待排序区，对省余的n-1个记录进行同，样的操作，关键字次大（小）的记录交换到，第n-1个位置上；依次类推，则完成排序。
对于初始为正序的文件，比较次数为 n-1，移动次数为 0，时间复杂度为 O(n)；
对于初始为逆序的文件，比较次数为 O（n^2），移动次数为 O（n^2），平均时间复杂度为 O（n^2）；
适合于数据较少的情况，排序n个记录的文件最多需要n-1趟冒泡排序。算法稳定。

1.6 快速排序

算法描述：附设两个指针low和high，初值分别指向第一个记录和最后一个记录，设关键字为 key，首先从high所指位置起向前搜索，找到第一个小于基准值的记录与基准记录交换，然后从low所指位置起向后搜索，找到第一个大于基准值的记录与基准记录交换，重复这两步直至low=high为止。
快速排序的算法分析：比较次数： O(nlog2n) ，平均时间复杂度：O(nlog2n) ，空间复杂度：O(log2n) ，算法是不稳定的，快速排序有可能出现最坏情况，这时快速排序算法的时间复杂度为O(n2)，且递归深度为n，即所需栈空间为O(n)。

1.7 归并排序

按每次归并的子文件数量可以分为二路归并，三路归并等等~~~这里就着重聊聊二路归并~~~
基本思想：把具有n个记录的表看成是n个有序的子表，每个子表的长度为1，然后两两归并，得到[n/2]个长度为2或为1的有序子表；再两两归并，如此重复，直到得到一个长度为n的有序表为止。
归并算法分析：平均时间复杂度：O(nlog2n) ，空间复杂度：O(n) ，算法是稳定的。

1.7.1两组归并算法

首先是两组归并算法。设t1[low]到t1[mid]和t1[mid+1]到t1[high]是存储在同一个数组中且相邻的两个有序的子文件，现在将这两个子文件合并为一个有序的文件，并存储在t2[low]到t2[high]中。

void Merge(table t1[],table t2[],int low ,int mid, int hight){
int i,j,k;
i = low;
j = mid + 1;
k = low;
while(( i <= mid) && (j <= hight)){
if(t1[i].key < t1[j].key){
t2[k++] = t1[i++];
}
else
t2[k++] = t1[j++];
}
/*将剩余的数组复制到新的数组中*/
while(i <=mid)
t2[k++] = t1[i++];
while(j <= hight)
t2[k++] = t1[j++];
}

1.7.2一趟归并算法

设各子文件长度为len(最后一个子文件长度可能小于len)，则归并前t1[0]到t1[n-1]中共有[n/len]个有序的子文件∶t1[0]到t1[len-1]，t1[len]到t1[2*len-1]，......，,t1[(-1)*length]到t1[n-1]，调用归并操作将相邻的一对子文件归并。

void MergePass(table t1[],table t2[],int n, int len){
int i,j;
i = 0;
while((i + 2*len - 1) < n){
Merge(t1,t2,i,(i+len - 1),(i + 2*len -1));/*并归两个长度为len的子文件到t2中*/
i += 2*len;
}
if(( i + len -1 ) < (n-1))/*剩下两个子文件，其中一个长度小于len*/
Merge(t1,t2,i,i+len - 1,n-1);
else
for(j = i;j < n ;j++)/*将最后一个子文件复制到t2数组中*/
t2[j] = t1[j];
}

1.7.3 二路归并算法

二路归并排序就是多次调用“一趟归并”过程，每趟归并后有序子文件的长度length扩大一倍。

void MergeSort(table t[],int len){
table record[MAX];
int lenght = 1;/*子文件长度*/
while(lenght < MAX){
MergePass(t,record,len,lenght);
lenght *=2;
MergePass(record,t,len,lenght);
lenght *=2;
}
}

二、代码分析

分析完算法，下面直接上干粮~~~

#include<stdio.h>
#define MAX 10//数组长度
typedef struct table table;struct table{int key;int other;
};
table t[MAX];/*直接插入,len 为数组长度*/
void insert(table t[],int len){int i,j;/*i 的前面是已排序，i的后面还未排序*/table flag;for(i = 1 ;i < len;i++){       /*每次将i后面的第一个插入到i的前面已排序列*/if(t[i].key < t[i-1].key){flag = t[i];j = i-1;while( (flag.key < t[j].key) && (j >= 0)){/*按升序排列*/t[j+1] = t[j];j--;}t[j+1] = flag;}}
}
/*折半插入，len为数组长度*/
void BinsertSort(table t[],int len){int i,j,low,hight,mid;table t1;for(i = 1;i < len;i++){t1 = t[i];/*i 为要排序的点*/low = 0;hight = i-1;while(low <= hight){mid = (low + hight)/2;if(t1.key < t[mid].key)hight = (mid -1);elselow = mid + 1;}for(j = i-1;j >=low;j--)t[j + 1] = t[j];t[low] = t1;}
}
/*选择排序，len是数组长度*/
void selectSort(table t[],int len){int i,j,k;table t1;for(i = 0;i < len; i++ ){k = i;/*k 是i轮最小的数*/for(j = i+1;j< len;j++){if(t[j].key < t[k].key)k = j;}/*将最小的换到i处*/if(k!=i){t1 = t[k];t[k] = t[i];t[i] = t1;}}
}
/*构造堆,len是数组长度,k是树根*/
void SIFT(table t[],int len ,int k){table t1;int i,j;i = k;j = 2 * i;t1 = t[i];/*t1 是 t[i]的左节点*/while(j < len){if((j < (len -1)) && (t[j].key < t[j+1].key ))j++;  if(t1.key < t[j].key)  // child 指向Ri的左、右子女中排序码较大的结点{t[i] = t[j];i = j;j = 2 * i;/*进入下一层继续调整*/}elsebreak;}t[i] = t1;// 将记录Ri放入正确位置}
/*堆排序算法*/
void heapSort(table t[],int len){int i;table t1;/*建立初始堆*/for(i = len/2 -1;i >= 0; i--){SIFT(t,len,i);}/* 进行n-1趟堆排序*/for(i = len -1;i>0;i--){/* 堆顶和最后一个互换 */t1 = t[0];t[0] = t[i];t[i] = t1;SIFT(t,i,0);// 从R0到Ri-1重建堆}
}
/*冒泡排序*/
void bubSort(table t[],int len){int i,j = 1,flag = 1;table t1;while((j < len ) && (flag > 0)){flag =0;/*记录第j次比较中有多少个错位的，若没有则停止排序*/for(i = 0;i < len -j;i++){if(t[i].key > t[i +1].key){flag++;t1 = t[i];t[i] = t[i +1];t[i + 1] = t1;}}j++;}
}
/*快速排序*/
void quickSort(table t[],int low,int hight){int i,j;i = low;j = hight;if(i >= j) return;table t1;t1 = t[i];/*将小于t1的都放在前面，大于t1的都在后面*/while(i != j){/*从高处向低处扫*/while((t1.key <= t[j].key) && (j>i))j--;if(i <j)t[i] = t[j];/*从低处向高处扫*/while((t[i].key <= t1.key ) && (j>i)){i++;}if(i < j)t[j] = t[i];}t[i] = t1;quickSort(t,low,i-1);quickSort(t,i+1,hight);
}
/*两组并归算法，将t1 并归到 t2数组中*/
void Merge(table t1[],table t2[],int low ,int mid, int hight){int i,j,k;i = low;j = mid + 1;k = low;while(( i <= mid) && (j <= hight)){if(t1[i].key < t1[j].key){t2[k++] = t1[i++];}elset2[k++] = t1[j++];}/*将剩余的数组复制到新的数组中*/while(i <=mid)t2[k++] = t1[i++];while(j <= hight)t2[k++] = t1[j++];
}
/*一趟并归，n 为数组长度，len为子文件长度,将t1 并归到 t2数组中*/
void MergePass(table t1[],table t2[],int n, int len){int i,j;i = 0;while((i + 2*len - 1) < n){Merge(t1,t2,i,(i+len - 1),(i + 2*len -1));/*并归两个长度为len的子文件到t2中*/i += 2*len;}if(( i + len -1 ) < (n-1))/*剩下两个子文件，其中一个长度小于len*/ Merge(t1,t2,i,i+len - 1,n-1);elsefor(j = i;j < n ;j++)/*将最后一个子文件复制到t2数组中*/t2[j] = t1[j];
}
/*二路并归算法*/
void MergeSort(table t[],int len){table record[MAX];int lenght = 1;/*子文件长度*/while(lenght < MAX){MergePass(t,record,len,lenght);lenght *=2;MergePass(record,t,len,lenght);lenght *=2;}
}
void init(table t[],int len){int n[10] = {15,25,10,2,100,58,46,12,45,45};int i;for(i = 0;i < MAX;i++){t[i].key = n[i];}printf("\n\n\n原数组： \n\n");for(i = 0 ;i < MAX;i++){printf("[ %d ] ",t[i].key);}
}
void show(table t[]){int i;printf("\n");for(i = 0 ;i < MAX;i++){printf("[ %d ] ",t[i].key);}
}
void main(){init(t,MAX);printf("\n直接插入排序：\n");insert(t,MAX);show(t);init(t,MAX);printf("\n折半插入排序：\n");BinsertSort(t,MAX);show(t);init(t,MAX);printf("\n 选择插入：\n");selectSort(t,MAX);show(t);init(t,MAX);printf("\n 堆排序：\n");heapSort(t,MAX);show(t);init(t,MAX);printf("\n冒泡排序：\n");bubSort(t,MAX);show(t);init(t,MAX);printf("\n快速排序：\n");quickSort(t,0,(MAX-1));show(t);init(t,MAX);printf("\n二路并归排序：\n");MergeSort(t,MAX);show(t);
}