目录
一.基本思想
二.Hoare法
动态演示
三.挖坑法
动态演示
四.前后指针法
动态演示
五.快速排序优化
随机下标交换法
三路取中法
六.快速排序的特性
任取待排序元素序列中的某元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止。
假设我们让最左边为keyi(注意这个表示的是下标),且要排升序;
1.若最左边为keyi,则right先走,找比arr[keyi]小的,left后走,找比arr[keyi]大的,然后right与left交换;
当left和right相遇时,结束循环,最后交换arr[keyi]和arr[left];
再让keyi=left,接着递归它的左子列和右子列;
2.若最右边为keyi,则left先走,找比arr[keyi]大的,right后走,找比arr[keyi]小的,然后right与left交换;
当left和right相遇时,结束循环,最后交换arr[keyi]和arr[left];
再让keyi=right,接着递归它的左子列和右子列;
注意这里的keyi,left,right都是下标。
左子列的区间是begin到keyi-1;
右子列的区间是keyi+1到end;
void QuickSort(int* arr, int left,int right)
{
if (left >= right)
return;
int begain = left;
int end = right;
int keyi= left;
while (left < right)
{
//这里要先判断left=arr[keyi]) //找小
{
right--;
}
while (left < right && arr[left] <= arr[keyi]) //找大
{
left++;
}
Swap(&arr[left], &arr[right]); //交换
}
Swap(&arr[keyi], &arr[left]);
keyi = left;
QuickSort(arr, begain, keyi-1); //递归左子列
QuickSort(arr, keyi+1, end); //递归右子列
}
上面的Hoare法有很多坑,一不注意就容易写错,而挖坑法就没那么多坑了。
这个方法需要定义一个坑变量(hole),前面的Hoare法是交换两个元素,挖坑法是把值赋给坑位,然后更新一下坑位 。
void QuickSort(int* arr, int left, int right)
{
if (left >= right)
return;
int begain = left;
int end = right;
int keyi = left;
int hole = left; //坑变量
while (left < right)
{
while (left < right && arr[right] >= arr[leyi]) //找小
{
right--;
}
arr[hole] = arr[right]; //赋值给坑位
hole = right; //更新坑位
while (left < right && arr[left] <= arr[keyi]) //找大
{
left++;
}
arr[hole] = arr[left];
hole = left;
}
arr[hole] = key;
keyi = left;
//递归左右子列
QuickSort(arr, begain, hole - 1);
QuickSort(arr, hole + 1, end);
}
这个方法可以说是实现快速排序最常用的方法了。
1.定义一个prev和cur,它们都表示数组的下标,当然你定义成指针也没问题,这里以下标为例;
2.cur=prev+1
注意:
a.prev要么紧跟着cur,即prev的下一个就是cur;
b.prev跟cur中间隔着比key大的一段值区间;
3.cur找到比key小的值,prev++,cur和prev位置互换,cur++;
4.cur找到比key大的值,cur++;
5.当cur>right时结束循环。
void QuickSort(int* arr, int left, int right)
{
if (left >= right)
return;
int begin = left, end = right;
int prev = left, cur = left + 1;
int keyi = left;
while (cur <= right)
{
if (arr[cur] < arr[keyi])
{
prev++;
Swap(&arr[cur], &arr[prev]);
cur++;
}
while (arr[cur] > arr[keyi])
{
cur++;
}
}
Swap(&arr[keyi], &arr[prev]);
keyi = prev;
QuickSort(arr, begin, keyi - 1);
QuickSort(arr, keyi + 1, end);
}
在面对有序或是接近有序的情况下,快速排序的效率不高,是O(N^2),那要怎么解决这个问题呢?
既然对有序或是接近有序的不行,那我们就打乱它的顺序,这里有两种方法:
1.通过生成区间内的随机下标,让keyi与randi的数据交换,这样就打乱了原来的顺序;
2.三路取中法。
int randi = left + rand() % (right - left); //随机key
Swap(&arr[keyi], &arr[randi]);
int GetMid(Sdatatype* arr, int left, int right)
{
int mid = (left + right) / 2;
if (arr[left] < arr[mid])
{
if (arr[mid] < arr[right])
return mid;
else if (arr[right] < arr[left])
return left;
else
return right;
}
else //arr[left]>arr[mid]
{
if (arr[right] < arr[mid])
return mid;
else if (arr[right] > arr[left])
return left;
else
return right;
}
}
if (left != midi)
Swap(&arr[left], &arr[midi]);
1. 快速排序整体的综合性能和使用场景都是比较好的,所以才敢叫快速排序
2. 时间复杂度:O(N*logN)
3. 空间复杂度:O(logN)
4. 稳定性:不稳定
本篇文章到此就结束了,若有错误或是建议的话,欢迎小伙伴们指出;️
希望小伙伴们能支持支持博主啊,你们的支持对我很重要哦;
谢谢你的阅读。