以下内容来自《大话数据结构》一书的附带源代码。
/*
-----------------------------------------------------------
平均时间复杂度 空间复杂度
排序:插入排序类 直接插入排序 O(n^2)
希尔排序 O(n^1.3)
选择排序类 简单选择排序 O(n^2)
堆排序 O(n*logn)
交换排序类 冒泡排序 O(n^2)
快速排序 O(n*logn)
归并排序类 归并排序 O(n*logn)
-----------------------------------------------------------
时间复杂度:问题规模 n , 时间复杂度O(f(n))
大O阶方法:
1、常数阶O(1) : 执行次数与 n 无关
2、线性阶O(n) : 一重n次循环 for(int i = 0; i<n; i++)
3、对数阶O(logn) :
int count = 1;
while(count < n) {count = count * 2;} //执行次数x为:2^x = n
4、平方阶O(n^x) : x重n次循环
空间复杂度:
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <io.h>
#include <math.h>
#include <time.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAX_LENGTH_INSERT_SORT 7 /* 用于快速排序时判断是否选用插入排序阙值 */
typedef int Status;
#define MAXSIZE 10000 /* 用于要排序数组个数最大值,可根据需要修改 */
typedef struct
{
int r[MAXSIZE+1]; /* 用于存储要排序数组,r[0]用作哨兵或临时变量 */
int length; /* 用于记录顺序表的长度,r[1]--r[length]顺序表共length个元素 */
}SqList;
/* 打印出L中数组r的元素 */
void print(SqList L)
{
int i;
for(i=1;i<L.length;i++)
printf("%d,",L.r[i]);
printf("%d",L.r[i]); //打印出r[length]
printf("\n");
}
/* 交换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 BubbleSort0(SqList *L)
{
int i,j;
for(i=1;i < L->length;i++)
{
for(j=i+1;j<=L->length;j++) // 第i个元素分别与i后面的元素比较大小
{
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->r[j+1]的值 */
}
}
}
}
/* 对顺序表L作 改进冒泡算法 *******************************************************************/
void BubbleSort2(SqList *L)
{
int i,j;
Status flag = TRUE; /* flag用来作为标记 */ //Status : int类型的重定义
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 */
} /* 如果一轮下来都没有数据交换,那就证明数组已经排好序啦 */
}
}
}
/* 对顺序表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]的值 */
}
}
/* 对顺序表L作 直接插入排序 *******************************************************************/
//将元素依次插入到已排序中去
void InsertSort(SqList *L)
{
int i,j;
for(i=2;i<=L->length;i++)
{
/*i之前的元素都已经排好序了,判断i元素是否大于i-1元素,若小于则需找到i元素的插入点*/
if (L->r[i] < L->r[i-1])
{
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]; /* 插入到正确位置 */
}
}
}
/* 对顺序表L作 希尔排序 ***********************************************************************/
//先按增量分组,之后各分组执行直接插入排序
/*如:7,9,2,3,6,9,44,66,12 增量为3
则分为3组:7,3,44 和 9,6,66 和 2,9,12*/
void ShellSort(SqList *L)
{
int i,j,k = 0;
int increment = L->length;
do
{
increment = increment/3 + 1; /* 增量序列 */ //这个增量也可用其他取法
for(i=increment+1;i<=L->length;i++) /*这个循环里面原理同直接插入排序*/
{
if (L->r[i] < L->r[i-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[j]; /* 记录后移,查找插入位置 */
L->r[j+increment] = L->r[0]; /* 插入 */
}
}
printf("第%d趟排序结果: ",++k);
print(*L);
}
while(increment>1); //当增量大于1时继续排序
}
/* 堆排序***************************************************************************************/
/*
大顶堆:1、完全二叉树,2、每个节点的值 >= 其左右子节点的值
小顶堆:1、完全二叉树,2、每个节点的值 <= 其左右子节点的值
*/
/* 已知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];
//画个堆出来便知:若S是父节点,则2*s是其左子节点,2*s+1是右子节点
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上 */ //break 跳出for循环
L->r[s] = L->r[j];
s = j;
}
L->r[s] = temp; /* 插入 */
}
/* 对顺序表L进行 堆排序 */
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); /* 将堆顶记录(第1个元素) 和 当前未经排序子序列的最后一个记录交换(第i个元素) */
HeapAdjust(L,1,i-1); /* 将L->r[1..i-1]重新调整为大根堆,L->r[i..length]为已排序的*/
}
}
/* 归并排序*************************************************************************************/
/* 将有序的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+l] = SR[i+l]; /* 将剩余的SR[i..m]复制到TR */
}
if(j<=n)
{
for(l=0;l<=n-j;l++)
TR[k+l] = SR[j+l]; /* 将剩余的SR[j..n]复制到TR */
}
}
/* 递归法 */
/* 将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[s..m]归并为有序的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] */
}
}
/* 对顺序表L作 归并排序 */
void MergeSort(SqList *L)
{
MSort(L->r,L->r,1,L->length);
}
/* 非递归法 */
/* 将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,i+2*s-1);
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];
}
/* 对顺序表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;/* 子序列长度加倍 */
}
}
/* 快速排序*************************************************************************************/
/* 交换顺序表L中子表的记录,使枢轴记录到位,并返回其所在位置
此时在它之前的记录均小于它;在它之后的记录均大于它。 */
int Partition(SqList *L,int low,int high)
{
int pivotkey;
pivotkey = L->r[low]; //取枢轴方法:1、取第一个关键字;2、随机取得;3、三数取中法
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; /* 返回枢轴所在位置 */
}
/* 对顺序表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作 快速排序 */
void QuickSort(SqList *L)
{
QSort(L,1,L->length);
}
/* 改进后快速排序*******************************************************************************/
/* 快速排序优化算法 */
int Partition1(SqList *L,int low,int high)
{
int pivotkey;
/*与Partition不同的是:这里取枢轴用了 三数取中法*****************/
int m = low + (high - low) / 2; /* 计算数组中间的元素的下标 */
if (L->r[low] > L->r[high])
swap(L,low,high); /* 交换左端与右端数据,保证左端较小 */
if (L->r[m] > L->r[high])
swap(L,high,m); /* 交换中间与右端数据,保证中间较小 */
if (L->r[m] > L->r[low])
swap(L,m,low); /* 交换中间与左端数据,保证左端较小 */
/*****************************************************************/
pivotkey = L->r[low]; /* 用子表的第一个记录作枢轴记录 */
L->r[0] = pivotkey; /* 将枢轴关键字备份到L->r[0] */
while(low<high) /* 从表的两端交替地向中间扫描 */
{
while(low<high&&L->r[high]>=pivotkey)
high--;
L->r[low]=L->r[high];
while(low<high&&L->r[low]<=pivotkey)
low++;
L->r[high]=L->r[low];
}
L->r[low]=L->r[0];
return low; /* 返回枢轴所在位置 */
}
void QSort1(SqList *L,int low,int high)
{
int pivot;
if( (high-low) > MAX_LENGTH_INSERT_SORT/*宏:7*/ )
{
while(low<high)
{
pivot = Partition1(L,low,high); /* 将L->r[low..high]一分为二,算出枢轴值pivot */
QSort1(L,low,pivot-1); /* 对低子表递归排序 */
/* QSort(L,pivot+1,high); 对高子表递归排序 */
//第一次递归后,变量low 就没有用处了,所以这样比QSort缩短了堆栈深度,从而提高了整体性能。
low = pivot+1; /* 尾递归 */
}
}
else //比较短的适合用 直接插入排序
InsertSort(L); /* 对顺序表L作 直接插入排序 */
}
/* 对顺序表L作 改进快速排序 */
void QuickSort1(SqList *L)
{
QSort1(L,1,L->length);
}
/* *********************************************************************************************/
#define N 9
int main()
{
int i;
/* int d[N]={9,1,5,8,3,7,4,6,2}; */
int d[N]={50,10,90,30,70,40,80,60,20};
/* int d[N]={9,8,7,6,5,4,3,2,1}; */
SqList l0,l1,l2,l3,l4,l5,l6,l7,l8,l9,l10;
for(i=0;i<N;i++)
l0.r[i+1]=d[i];
l0.length=N;
l1=l2=l3=l4=l5=l6=l7=l8=l9=l10=l0;
printf("排序前:\n");
print(l0);
printf("初级冒泡排序:\n");
BubbleSort0(&l0);
print(l0);
printf("冒泡排序:\n");
BubbleSort(&l1);
print(l1);
printf("改进冒泡排序:\n");
BubbleSort2(&l2);
print(l2);
printf("选择排序:\n");
SelectSort(&l3);
print(l3);
printf("直接插入排序:\n");
InsertSort(&l4);
print(l4);
printf("希尔排序:\n");
ShellSort(&l5);
print(l5);
printf("堆排序:\n");
HeapSort(&l6);
print(l6);
printf("归并排序(递归):\n");
MergeSort(&l7);
print(l7);
printf("归并排序(非递归):\n");
MergeSort2(&l8);
print(l8);
printf("快速排序:\n");
QuickSort(&l9);
print(l9);
printf("改进快速排序:\n");
QuickSort1(&l10);
print(l10);
/*大数据排序*/
/*
srand(time(0));
int Max=10000;
int d[10000];
int i;
SqList l0;
for(i=0;i<Max;i++)
d[i]=rand()%Max+1;
for(i=0;i<Max;i++)
l0.r[i+1]=d[i];
l0.length=Max;
MergeSort(l0);
print(l0);
*/
return 0;
}