最近一直在看排序,看到网课老师讲快排时,感觉好像很简单的样子,直到自己手动敲起了代码,才发现很多地方都有所欠缺,相信很多博友对于快排都不陌生,但是感觉这玩意离自己还是有那么一层纱,如果屏幕前的你也有这种感觉,那么接下来请随我一起揭开这一层薄纱,来一睹它的芳容. ----作者注
进阶排序的一般步骤(快排/归并):
1.问题的分解
2.子问题的递归
3.子问题解的合并
这里简单且草率地说一下快排和归并的联系(如果说的有问题,还望大牛批评指正):快排和归并是一对难兄难弟,快排重点是问题的分解,也就是第一部分Partiiton()上下了大功夫,到了第三部分,就没它什么事了,因为前两部分就已经把数组排序做好了.
归并排序不一样,归并排序在问题的分解上面很随意,取索引中间值作为划分依据,分为左数组和右数组,但是在问题的合并上下了狠功夫,归并排序以后再讲,这里主要讲的还是快排(没办法,因为快排优秀啊~时间复杂度和空间复杂度可接受程度更高,应用更广泛)
基本代码:
//最常见的双向移动指针partition
int Partition(vector& A, int begin, int end) {//问题的划分
int record = A[begin];
int i, j;
i = begin, j = end;
while (i <= j) {
while (A[i] <= record && i <= j) {
++i;
}
while (A[j] >= record && i <= j) {
--j;
}
if (i <= j) {
swap(A[i], A[j]);
}
}
swap(A[begin], A[j]);
return j;
}
void Quick_Sort(vector& A, int begin, int end)
{
if (begin < end) {
int q = Partition(A, begin, end);//问题的分解与解决
Quick_Sort(A, begin, q - 1);
Quick_Sort(A, q + 1, end);
}
}
这里的Quick_Sort()相当于问题的分解,就像是递归二叉树那样进行先序遍历,每一次划分就会使得左边的元素都小于当前元素A[i],这里千万要注意:不要把问题的划分Quick_Sort()和区间的划分Partiotion()混淆了,我们先不管Pariiton是怎么实现的,我们只要明白,对于一个数组,当你左边的元素都小于中间的元素(我们叫他主元),右边的元素都大于主元,递归调用结束后,程序就完成了(对于每个元素来说,左边的元素都是小于自己,右边的元素大于自己,这个数组不就整体有序了吗?)
Partition的三种解法
1.单向扫描分区法
基本思路:定义俩指针,sp起始指针指向A[left]的下一个元素,pivot保存起始值,起始bigger指向最后一个元素,判断sp指向的元素与起始值pivot的大小,如果大了,就和bigger指向的元素交换,先不管原来bigger指向的元素与pivot的大小关系,因为如果还是大了,我们还可以拿sp指针和向前移动一位的bigger指针再次交换,直到sp>bigger或者sp交换到了小于pivot的值
难点:1.当sp>bigger时,sp和bigger的指针位置?
2.最终我们A[left]和谁交换?SP?还是bigger?
int Partition(vector& A, int left, int right)
{//这里的left,right都表示索引
int pivot = A[left];
int sp = left + 1;
int bigger = right;
while (sp <= bigger) {
if (A[sp] <= pivot)sp++;
else {
swap(A[sp], A[bigger]);
bigger--;
}
}
swap(A[0], A[bigger]);//开始我们不确定这里
return bigger;//也不确定这里
}
初始情况,各指针指向位置如图
我们用图来模拟一下最终指向的位置情况:
经过一轮循环后,sp的位置会先等于bigger,再自己和自己交换,之后bigger会等于原来sp的位置(sp,bigger指针经过一次循环后调换了位置,我们可以得出结论,此时return bigger,swap(A[left],A[bigger]))
再来考虑这种情况:
此时的sp会自增两次到达bigger的右边停下,结束循环,那么我们还是可以发下bigger在sp的左侧,方法同上.
再来考虑这种情况:
交换完成后,sp==bigger,此时的sp指向的元素因为<=pivot,所以bigger又在sp的左边,又是同样的情况.
最后一种情况:我就不画图了,大家想一会明白,bigger两次自减,滑落到sp的左边,而sp左边的元素一定是<=pivot的,bigger就指向了最后一个小于等于pivot的元素,***又是***同样的情况,太巧妙了,不是吗?
2.最常见的方法:双向区间扫描法
随笔:虽然思想很简单,但是实现起来和上边一样,有很多细节要考虑,并且很多题目都是可以用双指针写的,要学会活学活用,用出精髓
思路:头尾指针向中间扫,当左指针停在>=pivot的位置,右指针停在<=pivot的位置,交换两者的位置
难点:考虑边界情况,最终的返回值等
先贴代码:
int Partition(vector& A, int begin, int end) {//问题的划分
int pivot = A[begin];
int i, j;
i = begin, j = end;
while (i <= j) {//注意内层while判断条件里也要写上i<=j,因为内层随时有可能突破这个条件
while (A[i] <= pivot && i <= j) {
++i;
}//左指针右移
while (A[j] >= pivot && i <= j) {
--j;//右指针左移
}
if (i <= j) {
swap(A[i], A[j]);
}//交换左右指针
}
swap(A[begin], A[j]);//未知
return j;//未知
}
同样的,我们考虑四种i,j的指向情况
这里的四种情况的模拟就交给大家啦,让大家更好的体悟循环后的语句是怎么写出来的已级到底是交换谁,到底是返回谁,这个问题.
正确答案:四种情况都是j总是在i的左边紧邻i,且j指向最后一个<=pivot的元素.
快排的重要应用selectK(建议熟记思路伪代码,先关题目经常用到它的变种)
题目描述:以尽量高的时间效率(不是尽量高的时间复杂度)求出一个乱序数组中从小到大的第K个元素值(不是下标为K,是第K个)
基本思路:每次划分,找划分元素为当前数组的第qK个,判断qk==k?如果大于k,就表示第k个元素一定在qK的左边,左递归,如果小于k,就表示第k个元素一定在qK的右边,则右递归,注意:递归的第k个元素变成递归的qK-k个元素
问:为何求qK时那里q-p+1加了1呢?**因为我们说N~M中M是这个序列的第(M-N+1)**号元素,比如:1 2,这个序列2是不是这个序列的第(2-1+1)号元素.
问:为何右递归时传入的参数是qK-k而不是qK-k+1呢?
答:因为这里的k和qK都表示说第…号元素,比如qK=3,k=4,q=2,
数组为:2 1 3 6 7 9
则传入的参数为(A,3,5,?)我们传入的参数应该是q+1,也就是从6开始算的,那么6就算是新数组的第一个元素了,我们再传入k-qK就表示求第一个元素的大小了.
int selectK(vector& A, int p, int r, int k)//要找的第K个元素
{
q = partition(A, p,r);
int qK = q - p + 1;//主元是第qk个元素
if (qK == k)return A[q];
else if(qK>k){//往左边收缩边界,还是找第k个元素
retrun seleckK(A, p, q - 1,k);
}
else {//右边要找的元素是第k-qk个,因为qK也表示第qK个元素,两者相减时不用减一
return selectK(A, q + 1, r,k-qK);
}
}
快排的理想情况,以及现实中的优化解法
快排为什么可以达到NlogN的复杂度呢?它最坏的情况又是什么呢?
我们先来看一张图
1.分析时间复杂度:每次问题都被分成两部分,那么一共有logN向下取整层(这里简化为logN层),每一层排序,双指针用法时间复杂度为O(N),层数为logN,每一层花的时间都是Partiton所花的时间复杂度O(N),所以最后平均(最好最坏)总的时间复杂度就是O(N*logN),简要记忆推导,上面的就足够了
详细推导可以参考这位神牛牪犇的博客:
神牛牪犇博客
2.这种图很理想主义,每次我们取的pivot总是可以把数组划分为左右两段,但是现实是,最坏的情况:所有元素都比我们选取的要大或者小,此时这个排序就退化为插入排序,时间复杂度斜线上升到O(n^2),所以选择pivot元素就很有讲究了.我们希望每次选取的pivot都可以把数组化分为左一半,右一半,而且二者大小基本相等.
但是如果划分出来的元素个数左右绝对相等,又会多出来"找出这个绝对中值元素"的时间复杂度,很多时候也并不合算,所以,我们在现实中(比赛中)往往使用三点中值法.
我们在A[left],A[mid],A[right]三个元素中选择介于中间的元素,我们总不会那么倒霉,也就好比是原来出门踩香蕉皮摔倒的概率是%70,现在减少到%33.333(23333333).
而且更重要的是,这个比较操作很简单,花费的时间复杂度还是常数级别的,可以说四两拨千斤吧~
这里还是贴出代码:
int Partition(vector& A, int begin, int end) {//问题的划分
int mid_Index;
int mid = begin + ((end - begin) >> 1);
if ((A[begin] >= A[mid] && A[begin] <= A[end])||(A[begin] >= A[end] && A[begin]<=A[mid]))
{
mid_Index = begin;
}
else if ((A[end] >= A[mid] && A[end] <= A[begin]) || (A[end] >= A[begin] && A[end] <= A[mid]))
{
mid_Index = end;
}
else {
mid_Index = mid;
}
swap(A[mid_Index], A[begin]);
int record = A[begin];
int i, j;
i = begin, j = end;
while (i<=j) {
while (A[i] <= record&&i<=j) {
++i;
}
while (A[j] >= record&&i<=j) {
--j;
}
if (i <= j) {
swap(A[i], A[j]);
}
}
swap(A[begin], A[j]);
return j;
}
感想
最后再来说说为什么这一篇做的这么认真(随便) 吧.
短学期,空荡的机房,一个人的寝室,似乎也就只有陌生人的力量才能让我觉得片刻的温暖…
当我正打算漫不经心地再水一篇博客时,突然看到有人评论我的文章,我的第一个反应是忐忑,想想是不是因为昨天的博文最后因为时间匆忙,有些烂尾,被人指责不认真,太过随意,最终,自嘲地想想,可能好歹别人还算是愿意给你指出来哪里不对,你不应该虚心接受吗?在超我以及好奇心的驱使下我点开了评论,出乎我意料,竟然是鼓励,说我写的认真,那一刻,我很不争气地泪目了,我突然觉得很对不起他,我写的并没有那么好,但是,他就是那样,夸赞了我的认真,这对他而言真的是一件微乎其微的小事,但是这可能是,这个冬天,我收到过的最暖心的礼物了,谢谢你QWQ.
我保证在接下来寒假时间里,会做出更多高质量的文章来回馈那些给我温暖的人,同时,如果文章里有哪些内容不懂,或者我写的某处有错误,也都欢迎大家私信或者评论指出.
赠人玫瑰,手有余香,祝:生活愉快!
标签：begin,sp,end,版包,int,元素,精解,bigger,图文
来源： https://blog.csdn.net/Alanadle/article/details/111992103
398
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
