快速排序代码详解&进阶玩法

前言

 大二下算法设计课快排被卡，才想起来好好看看快排。被sort（）惯得，太晚了喂 其实是对卡经典快排出题人的反制，出于这种目的造出来一些神必的写法，这里我们假设大家都已经知道快排怎么写了啊。

经典写法

 快排主要思想是选择一个枢轴量位置$pivot$，将序列中的所有数归三类：

1. $x\le pivotValue$
2. $x=pivotValue$
3. $x\ge pivotValue$

 将第一类数堆到序列左边，第三类数堆到序列右边，第二类数不管，然后在中间插上一个$pivotValue。$这里放出个人比较喜欢的一种写法 抄的

int partition(int l,int r) {
	int low = l,high = r;
    int pivot = l;          //虚假的pivot，此处无用，便于和下方代码统一
	swap(Ypos[l],Ypos[pivot]);
	int val = Ypos[l];      //真正的pivot可以看做l
	while(low < high) {
	    //两句while不能颠倒，必须从high一方先进行判断，然后从low一方进行判断
		while(Ypos[high] >= val && high > low) high--;
		while(Ypos[low] <= val && high > low) low++;
		if(low < high)
		    swap(Ypos[low],Ypos[high]);
	}
	Ypos[l] = Ypos[high];  
	Ypos[high] = val;       //将pivotValue插回序列，它该去的位置是循环终止的位置low == high
	return high;
}

int Qsort(int l,int r,int k) {
	if(l < r) {
		int pos = partition(l,r); 
		//获得pivot，此时左边不大于pivotValue，右边不小于pivotValue
		Qsort(l,pos-1,k);
		Qsort(pos+1,r,k);
	}
}

一些解释：

• 实际上算法将$Y_{pos}[l]$当做了$pivotValue$，让$Y_{pos}[l]$做一个缓存放别的数。所以最终将可能没有跟$pivotValue$进行大小比较的$Y_{pos}[high==low]$ 丢给$Y_{pos}[l]$，将$pivotValue$插入到正确的位置$Y_{pos}[high]$。
• 诶等等，一个不知道大小的值丢给左边不会错吗？所以说两句$while$的顺序不能颠倒

    while(Ypos[high] >= val && high > low) high--;
    while(Ypos[low] <= val && high > low) low++;

• 注意到$swap(Y_{pos}[low],Y_{pos}[high])$时，是在$low<high$的情况下，找到一对儿不合适的位置进行交换的，这里我们将内层$while$循环停下的位置称作不合适的位置。那么最终会出现一个可能不合适且匹配不到交换的位置$low==high$，也就是循环终止的位置，我们能保证当前位置$Y_{pos}[high==low]\le pivotValue$。下面分情况讨论
  
• $Case1:$ $low$找到$high$，因为$high$指针先停到该位置所以满足条件$Y_{pos}[high]<pivotValue$。
• $Case2:$ $high$找到$low$并且$low>l$，可知$low$一定停下来过，因此在上一层循环中一定有与之交换的另一个$high$，并且它们已经$swap$。而在当前循环中$low$还没有移动，实际上$Y_{pos}[low]$中的值是上一层循环中$Y_{pos}[上一个high]$，满足$Y_{pos}[上一个high]<pivotValue$。
• $Case3:$ $high$找到$low$并且$low==l$，枢轴量就是$l$，显然满足$Y_{pos}[high==low]==pivotValue$。
   综上，保证了最后循环终止的位置的值满足扔到左边去的条件，因此经典快排是没有错误的，嗯。

经典的局限性

 经典算法好的不得了！但是它就是容易被卡，构造一组全部一样的数据，就能使得快排退化成$N^2$，问题仍然出在两个$while$循环上。若数据全部一样，每次返回的$pivot$都是$l$，子问题分的太不均匀了，每次分治问题的规模只能减一。

    while(Ypos[high] >= val && high > low) high--;
	while(Ypos[low] <= val && high > low) low++;

无济于事的随机化

 随机化快排，通过随机选择枢轴量$pivot$来避免极差的情况，实现上是随机选择一个位置，然后把它放到$Y_{pos}[l]$里，然后套用经典算法即可。

    int pivot = rand() % (r - l + 1) + l;
	swap(Ypos[l],Ypos[pivot]);

 在没搞明白之前，我还试图通过随机化来卡过全部一样的测试用例 （我是啥b） 。随机化在面对这种样例的时候完全无差，甚至还多了求随机数的时间。因为不管是否随机化，最终实际的枢轴量$pivot$都是$l$，从而陷入上方同样的局限性。在第一次$high$左移的过程中，它会一路狂飚到$l$的位置，使得问题的规模减一，完美。

着手点

 其实快排关键就在于枢轴量位置的选择，在面对完全一样的用例时，明明能够左右分半，却非要一次移动到底。由此启发限制一次$while$循环中$high$指针移动的长度，然后我对两个$while$进行了一系列魔改。

    while(Ypos[high] >= val && high > low) {
        high--;
		if(high > low && Ypos[low] <= val) low++; 
	} //后来放弃这个魔改了，太神必了而且WA了
	while(Ypos[low] <= val && high > low) low++;

 限制一次移动的长度不超过$Halflen$,那么刚才的最坏情况下现在变为右边移动一半，左边移动一半。我直接狂喜，$NlogN$你还卡得住？ 然后它WA了。

        cnt = 0; //cnt是当前移动次数，Halflen是区间长度一半向上取整
		while(Ypos[high] >= val && high > low) {
		    high--;
			if(cnt++ > Halflen) break;
		}
		cnt = 0;
		while(Ypos[low] <= val && high > low) {
			low++;
			if(++cnt > Halflen) break;
	    }
	    while(Ypos[high] >= val && high > low) high--;
		while(Ypos[low] <= val && high > low)  low++;

抢救&进阶玩法

 被$low$和$high$扫过的区间肯定是满足大小关系的，那么有问题的只能是可能没有跟$pivotValue$进行大小比较的$Y_{pos}[high==low]$，在魔改之后不能保证$Y_{pos}[high==low]\le pivotValue$了，但是没有改变的是最终位置$high==low$左边依旧是第一类数，右侧依然是第三类数。

 为了正确的归类，在插回$pivotValue$之前加一条特判。如果$Y_{pos}[high==low]$不能归类到左边就归类到右边，很简陋是不是hhh，但是这样就足够了。

	if(Ypos[high] > val)
	    high--; 

 洛谷快排模板跑135ms，只要AC就算成功。

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<ctime> 
#include<algorithm>

using namespace std;

const int MAXN = 2e6 + 5;
int Ypos[MAXN];
int n = 0,x,k;

void print(int *Arr) {
	for(int i = 1;i <= n;++i)
	    cout << Arr[i] << " ";
	cout << endl;
}

int partition(int l,int r) {
	int low = l,high = r,Halflen = (r-l+1) / 2 + 1;
    int pivot = rand() % (r - l + 1) + l;
    
	swap(Ypos[l],Ypos[pivot]);
	int val = Ypos[l],cnt;
	while(low < high) {
		cnt = 0;
		while(Ypos[high] >= val && high > low) {
		    high--;
			if(cnt++ > Halflen) break;
		}
		cnt = 0;
		while(Ypos[low] <= val && high > low) {
			low++;
			if(++cnt > Halflen) break;
	    }
	    while(Ypos[high] >= val && high > low) high--;
		while(Ypos[low] <= val && high > low) low++;
		
		if(low < high)
		    swap(Ypos[low],Ypos[high]);
	}
	
	if(Ypos[high] > val) high--; 
	Ypos[l] = Ypos[high];  
	Ypos[high] = val;
	
	return high;
}

int Qsort(int l,int r) {	
	if(l < r) {
		int pos = partition(l,r);
		Qsort(l,pos-1);
		Qsort(pos+1,r);
	}
}

int main() {
	std::ios::sync_with_stdio(false);
	cin >> n;
	for(int i = 1;i <= n;++i)
	    cin >> Ypos[i];
	    
	Qsort(1,n);
	print(Ypos); 
	return 0;
}

后记

 11点多开始码，中途写到3个$Case$时候发现逻辑有点问题再次构思，写到早上7点，沃柑以后不熬夜写文章了，早知道打把游戏睡觉…