开场白
这篇主要介绍归并排序和快速排序
归并排序
归并排序(Merging Sort) 就是利⽤归并的思想实现排序⽅法. 它的原理是假设初始序 列含有n个记录,则可以看成n个有序的⼦序列. 每个⼦序列的⻓度为1,然后两两合并.得 到[n/2]个⻓度为2或1的有序⼦序列, 再两两归并.......如此重复,直到得到⼀个⻓度为n 的有序序列为此. 这种排序⽅法称为2路归并排序。
示例模拟排序流程
r = [50,10,90,30,70,40,80,60,20] length = 9
- 获取中间下标，将数组分成两部分：[50,10,90,30,70] , [40,80,60,20]
- 讲子数组再进行分割：[50,10,90],[30,70] | [40,80],[60,20]
- 同理：[50,10],[90]|[30],[70] || [40], [80]|[60],[20]
- 最后结果：[50],[10]|[90] || [30]|[70] ||| [40]|[80] || [60]|[20]
- 按照上放的分割同级比较，进行排序
- [10,50],[90]|[30],[70] || [40], [80]|[60],[20]
- [10,50,90],[30,70]|[40,80]|[20,60]
- [10,30,50,70,90],[20,40,60,80]
- [10,20,30,40,50,60,70,80,90]
如图：
代码
1.递归方式
//合并函数，i代表低位，n代表高位，m代表中间位置
void Merge(int SR[], int TR[], int i, int m, int n) {
int j, k;
//SR分成两部分[i,m]和[m+1,n]，两部分中元素依次比较，较小的放入TR中
for (k = i, j = m+1; i<=m && j<=n; k++) {
if (SR[i]<SR[j]) {
TR[k]=SR[i++];
} else {
TR[k]=SR[j++];
}
}
//[i,m]部分没有结束，把未插入的元素插入到TR中
if (i <= m) {
for (int l = 0; l<= m-i; l++) {
TR[k+l]=SR[i+l];
}
}
//[m+1,n]部分没有结束，把未插入的元素插入到TR中
if (j <= n) {
for (int l = 0; l <= n-j; l++) {
TR[k+l]=SR[j+l];
}
}
}
//SR中low-high的元素进行归并排序
void MSort(int SR[], int TR1[], int low, int high) {
if (low == high) {//递归出口 递归到SR中只剩下一个元素的时候
TR1[low] = SR[low];
} else {
//去中间分隔元素下标
int mid = (low + high) / 2;
//创建TR2数组
int TR2[MAXSIZE +1];
//类似处理二叉树左子树的形式，递归进行SR中low-mid中的元素进行归并排序
MSort(SR, TR2, low, mid);
//类似处理二叉树右子树的形式，递归进行SR中（mid+1）-high中的元素进行归并排序
MSort(SR, TR2, mid + 1, high);
//将TR2中元素进行排序，将结果放到TR1中
Merge(TR2, TR1, low, mid, high);
}
}
//归并排序 入口
void MergeSort(SqList *L) {
MSort(L->r, L->r, 1, L->length);
}
2.非递归方式
void MergePass(int SR[], int TR[], int s, int length) {
int i = 1;
//①合并数组
//s=1 循环结束位置:8 (9-2*1+1=8)
//s=2 循环结束位置:6 (9-2*2+1=6)
//s=4 循环结束位置:2 (9-2*4+1=2)
//s=8 循环结束位置:-6(9-2*8+1=-6) s = 8时,不会进入到循环;
while (i <= length-2*s+1) {
//两两归并(合并相邻的2段数据)
Merge(SR, TR, i, i+s-1, i+2*s-1);
i = i+2*s;
/*
s = 1,i = 1,Merge(SR,TR,1,1,2);
s = 1,i = 3,Merge(SR,TR,3,3,4);
s = 1,i = 5,Merge(SR,TR,5,5,6);
s = 1,i = 7,Merge(SR,TR,7,7,8);
s = 1,i = 9,退出循环;
*/
/*
s = 2,i = 1,Merge(SR,TR,1,2,4);
s = 2,i = 5,Merge(SR,TR,5,6,8);
s = 2,i = 9,退出循环;
*/
/*
s = 4,i = 1,Merge(SR,TR,1,4,8);
s = 4,i = 9,退出循环;
*/
}
//②如果i<length-s+1,表示有2个长度不等的子序列. 其中一个长度为length,另一个小于length
// 1 < (9-8+1)(2)
//s = 8时, 1 < (9-8+1)
if (i < length-s+1) {
//Merge(SR,TR,1,8,9)
Merge(SR, TR, i, i+s-1, length);
} else {//③只剩下一个子序列;
for (int j = i; j <= length; j++) {
TR[j] = SR[j];
}
}
}
void MergeSort2(SqList *L) {
int *TR = (int *)malloc(sizeof(int) * L->length);
int k = 1;
//k的拆分变换是 1,2,4,8;
while (k < L->length) {
//将SR数组按照s=2的长度进行拆分合并,结果存储到TR数组中;
//注意:此时经过第一轮的归并排序的结果是存储到TR数组了;
MergePass(L->r, TR, k, L->length);
k = 2*k;
//将刚刚归并排序后的TR数组,按照s = 2k的长度进行拆分合并. 结果存储到L->r数组中;
//注意:因为上一轮的排序的结果是存储到TR数组,所以这次排序的数据应该是再次对TR数组排序;
MergePass(TR, L->r, k, L->length);
k = 2*k;
}
}
快速排序
快速排序(Quick Sort)的基本思想: 通过⼀趟排序将待排序记录分割成独⽴的两部分; 其中⼀部分记录的关键字均为另⼀部分记录的关键字⼩,则可分别对两部分记录继续进⾏排序,以达到整个排序有序的⽬的。
代码
int Partition(SqList *L, int low, int high) {
//默认中枢轴是第一个元素
int 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;
}
void QSort(SqList *L, int low, int high) {
if (low < high) {//递归出口
int pivot = Partition(L, low, high);//获取中枢轴
printf("pivot = %d L->r[%d] = %d \n", pivot, pivot, L->r[pivot]);
//递归处理，分两部分，[low,pivot-1]，[pivot+1,high]
QSort(L, low, pivot-1);
QSort(L, pivot + 1, high);
}
}
void QucikSort(SqList *L) {
QSort(L, 1, L->length);
}
代码实现逻辑：
- 默认第一个元素为中枢轴，把小于它的的元素放到前面，把大于它的元素放到后面。
- 根据中枢值，将原数组分成两部分
- 新分成的两部分记录递归第一步。
- 当low不小于high时，为递归出口。
优化快速排序
优化的点：
- 如果默认数组中low对应的值本来就是最小值，或者数组中部分元素是有序的，例如[2,3,4,5,6,7,9,8]这种情况每次再找中枢值的时候，进行的比较次数都很多。此处优化方案是使用low、high和mid值进行比较，取中间值的方式。
- 用哨兵记录中枢值，这样在while循环中，不调用交换方法，而是用中间值的方式进行赋值。
代码：
int Partition2(SqList *L, int low, int high) {
//优化获取中枢轴，如果下标low对应的值是最小值 或者 high对应的值是最大值，这要快排的效率会很低
//所以我们获取low、high、和中间下标m对应的三个值，进行比较，把中间值放在low的位置
int m = (low + high) / 2;
//low和high比较，相对小的放在low上
if (L->r[low] > L->r[high]) {
swap(L, low, high);
}
//m和high比较，把相对小的放在m上
if (L->r[m] > L->r[high]) {
swap(L, m, high);
}
//m和low比较，把相对大的放low上
if (L->r[m] > L->r[low]) {
swap(L, m, low);
}
//获取中枢值
int pivotkey = L->r[low];
//用哨兵记录中枢值，这样就不用频繁的进行交换了
L->r[0] = pivotkey;
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];
}
//将哨兵记录的值赋值给下标low上
L->r[low] = L->r[0];
return low;
}
#define MAX_LENGTH_INSERT_SORT 7 //数组长度的阀值
void QSort2(SqList *L, int low, int high) {
if ((high - low) > MAX_LENGTH_INSERT_SORT) {
int pivot = Partition(L, low, high);
printf("pivot = %d L->r[%d] = %d\n",pivot,pivot,L->r[pivot]);
QSort(L, low, pivot-1);
QSort(L, pivot+1, high);
} else {
InsertSort(L);
}
}
void QuickSort2(SqList *L) {
QSort2(L, 1, L->length);
}
