1.冒泡排序
冒泡排序（Bubble Sort）一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序列交换，直到没有反序的记录为止。
排序用到的结构与函数
#define MAXSIZE 10 //用于要排序数组个数最大值，可根据需要修改
typedef struct{
int r[MAXSIZE]; //用于存储要排序数组，r[0]用作哨兵或临时变量
int length; //用于记录顺序表的长度
}SqList;
//交换L中数组r的下标为i和j的值
void swap(SqList *L, int i, int j){
int temp = L->r[i];
L->r[i] = L->r[j];
L->r[j] = temp;
}
下面是三种不同的冒泡实现代码
//对顺序表L作交换排序（冒泡排序初级版）
void BubbleSort(SqList *L){
int i, j;
for(i=1; i<L->length; i++){
for(j=i+1; j<=L->length; j++){
if(L-r[i] > L->r[j]){
swap(L, i, j); //交换L->r[i]与L->r[j]的值
}
}
}
}
//对顺序表L作冒泡排序
void BubbleSort(SqList *L){
int i, j;
for(i=1; i<L->length; i++){
for(j=L->length-1; j>=i; j--){ //注意j是从后往前循环
if(L->r[j] > L->r[j+1]){ //若前者大于后者（注意这里与上一算法差异）
swap(L, j, j+1); //交换L->r[j]与L->j[j+1]的值
}
}
}
}
冒泡排序优化
//对顺序表L作改进冒泡算法
void BubbleSort2(SqList *L){
int i, j;
Status flag = TRUE; //flag用来作为标记
for(i=1; i<L->length && flag; i++){ //若flag为true则退出循环
flag = FALSE; //初始为false
for(j=L->length-1; j>=i; j--){
if(L->r[j] > L->r[j+1]){
swap(L, j, j+1); //交换L->r[j]与L->r[j+1]的值
flag = TRUE; //如果有数据交换，则flag为true
}
}
}
}
2.简单选择排序
简单选择排序法（Simple Selection Sort）就是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i(1<=i<=n)个记录交换之。
//对顺序表L作简单选择排序
void SelectSort(SqList *L){
int i, j, min;
for(i=1; i<L->length; i++){
min = i; //将当前下标定义为最小值下标
for(j=i+1; j<=L->length; j++){ //循环之后的数据
if(L->r[min] > L->r[j]) //如果有小于当前最小值的关键字
min = j; //将此关键字的下标赋值给min
}
if(i != min) //若min不等于i，则说明找到最小值，交换
swap(L, i, min); //交换L->r[i]与L->r[min]的值
}
}
3.桶排序
桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。
void BucketSort(SqList *L){
int vis[1000]={0}; //首先将所有桶的标记都重置为 0
int i, j;
for(i=1; i<=L->length; i++){
vis[L->r[i]]++; //进行计数
}
for(i=1; i<=1000; i++){
for(j=0; j<vis[i]; j++){ //根据次数打印数据
printf("%d ", i); //没有标记的为0那么就不会打印出来
}
}
}
4.直接插入排序
直接插入排序（Straight Insertion Sort）的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数增1的有序表。
//对顺序表L作直接插入操作
void InsertSort(SqList *l){
int i, j;
for(i=2; i<=L->length; i++){
if(L->r[i] < L->r[i-1]){ //需将L->r[i]插入有序子表
L->r[0] = L->r[i]; //设置哨兵
for(j=i-1; L->r[j]>L->r[0]; j--)
L->r[j+1] = L->r[j]; //记录后移
L->r[j+1] = L->r[0]; //插入到正确位置
}
}
}
5.希尔排序
希尔排序（Shell Sort）是D.L.Shell于1959年提出来的一种排序算法，在这之前排序算法的时间复杂度基本都是O[n2]的，希尔排序算法是突破了这个时间复杂度的第一批算法之一。
//对顺序表L作希尔排序
void ShellSort(SqList *L){
int i, j;
int increment = L->length;
do{
increment = increment/3 + 1; //增量序列
for(i=increment+1; i<=L->length; i++){
if(L->r[i] < L->r[increment]){ //需将L->r[i]插入有序增量子表
L->r[0] = L->r[i]; //暂存在L->r[0]
for(j=i-increment; j>0 && L->r[0]<L->r[j]; j-=increment)
L->r[j+increment] = L->r[0]; //记录后移，查找插入位置
L->r[j+increment] = L->r[0]; //插入
}
}
}while(increment > 1);
}
这其实就是希尔排序的精华所在，它将关键字较小的记录，不是一步一步地往前挪动，而是跳跃式的往前移，从而使得每次完成一轮循环后，整个序列就朝着有序坚实地迈进一步。
6.堆排序
堆排序（Heap Sort），就是对简单选择排序进行的一种改进，这种改进的效果是非常明显的。堆排序算法是Floyd和Williams在1964年共同发明的，同时，他们发明了“堆”这样的数据结构。
堆是具有下列性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。
堆排序（Heap Sort）就是利用堆（假设利用大顶堆）进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是将其与堆数组的末元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构造成一个堆，这样就对得到n个元素中的此大值。如此反复执行，便能得到一个有序序列了。
void HeapSort(SqList *L){
int i;
for(i=L->length/2; i>0; i--) //把L中的r构建成一个大顶堆
HeapAdjust(L, i, L->length);
for(i=L->length; i>1; i--){
swap(L, 1, i); //将堆顶记录和当前未经排序子序列的最后一个记录交换
HeapAdjust(L, 1, i-1); //将L->r[1..i-1]重新调整为大顶堆
}
}
//已知L->r[s..m]中记录的关键字除L->r[s]之外均满足堆的定义
//本函数调整L->r[s]的关键字，使L->r[s..m]成为一个大顶堆
void HeapAdjust(SqList *L, int s, int m){
int temp, j;
temp = L->r[s];
for(j=2*s; j<=m; j*=2){ //沿关键字较大的孩子结点向下筛选
if(j<m && L->r[j]<L->r[j+1])
++j; //j为关键字中较大的记录的下标
if(temp >= L->r[j])
break; //rc应插入在位置s上
L->r[s] = L->r[j];
s = j;
}
L->r[s] = temp; //插入
}
7.归并排序
归并排序（Merging Sort）就是利用归并的思想实现的排序方法。它的原理是假设初始序列含有n个元素，则可以看成n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]（[x]表示不小于x的最小整数）个长度为2或1的有序子序列；再两两归并，……，如此重复，直至得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序。
归并排序的递归实现代码
void MergeSort(SqList *L){
MSort(L->r, L->r, 1, L->length);
}
//将SR[s..t]归并排序为TR1[s..t]
void MSort(int SR[], int TR1[], int s, int t){
int m;
int TR2[MAXSIZE+1];
if(s == t)
TR1[s] = SR[s];
else{
m = (s+t)/2; //将SR[s..t]平分为SR[s..m]和SR[m+1..t]
MSort(SR, TR2, s, m); //递归将SR[m+1..t]归并为有序TR2[s..m]
MSort(SR, TR2, m+1, t); //递归将SR[m+1..t]归并为有序TR2[m+1..t]
Merge(TR2, TR1, s, m, t);//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
}
}
//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
void Merge(int SR[], int TR[], int i, int m, int n){
int j, k, l;
for(j=m+1, k=i; i<=m && j<=n; k++){ //将SR中记录由小到大归并入TR
if(SR[i] < SR[j])
TR[k] = SR[i++];
else
TR[k] = SR[j++];
}
if(i <= m){
for(l=0; l<=m-i; l++)
TR[k+1] = SR[i+1]; //将剩余的SR[i..m]复制到TR
}
if(j <= n){
for(l=0; l<=n-j; l++)
TR[k+1] = SR[j+1]; //将剩余的SR[j..n]复制到TR
}
}
归并排序的非递归实现代码
//对线性表L作归并非递归排序
void MergeSort2(SqList *L){
int *TR = (int *)malloc(L->length*sizeof(int)); //申请额外空间
int k = 1;
while(k < L->length){
MergePass(L->r, TR, k, L->length);
k = 2*k; //子序列长度加倍
MergePass(TR, L->r, k, L->length);
k = 2*k; //子序列长度加倍
}
}
//将SR[]中相邻长度为s的子序列两两归并到TR[]
void MergePass(int SR[], int TR[], int s, int n){
int i = 1;
int j;
while(i <= n-2*s+1){
Merge(SR, TR, i, i+s-1, n); //两两归并
i = i+2*s;
}
if(i < n-s+1) //归并最后两个序列
Merge(SR, TR, i, i+s-1, n);
else //若最后只剩下单个子序列
for(j=i; j<=n; j++)
TR[j] = SR[j];
}
8.快速排序
快速排序（Quick Sort）的基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录进行继续排序，以达到整个序列有序的目的。
//对顺序表L作快速排序
void QuickSort(SqList *L){
QSort(L, 1, L->length);
}
//对顺序表L中的子序列L->r[low..high]作快速排序
void QSort(SqList *L, int low, int high){
int pivot;
if(low < high){
pivot = Partition(L, low, high); //将L->r[low..high]一分为二，算出枢纽值pivot
QSort(L, low, pivot-1); //对低子表递归排序
QSort(L, pivot+1, high); //对高子表递归排序
}
}
//交换顺序表L中子表的记录，使枢纽记录到位，并返回其所在位置
//此时在它之前（后）的记录均不大（小）于它
int Partition(SqList *L, int low, int high){
int pivotkey;
pivotkey = L->r[low]; //用子表的第一个记录作枢纽记录
while(low < high){ //从表的两端交替向中间扫描
while(low<high && L->r[high]>=pivotkey)
high--;
swap(L, low, high); //将比枢纽记录小的记录交换到低端
while(low<high && L->r[low]<=pivotkey)
low++;
swap(L, low, high); //将比枢纽记录大的记录交换到高端
}
return low; //返回枢纽所在位置
}
