前言
大二下算法设计课快排被卡,才想起来好好看看快排。被sort()惯得,太晚了喂 其实是对卡经典快排出题人的反制,出于这种目的造出来一些神必的写法,这里我们假设大家都已经知道快排怎么写了啊。
经典写法
快排主要思想是选择一个枢轴量位置 p i v o t pivot pivot,将序列中的所有数归三类:
- x ≤ p i v o t V a l u e x \leq pivotValue x≤pivotValue
- x = p i v o t V a l u e x = pivotValue x=pivotValue
- x ≥ p i v o t V a l u e x \geq pivotValue x≥pivotValue
将第一类数堆到序列左边,第三类数堆到序列右边,第二类数不管,然后在中间插上一个
p
i
v
o
t
V
a
l
u
e
。
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 p o s [ l ] Y_{pos}[l] Ypos[l]当做了 p i v o t V a l u e pivotValue pivotValue,让 Y p o s [ l ] Y_{pos}[l] Ypos[l]做一个缓存放别的数。所以最终将可能没有跟 p i v o t V a l u e pivotValue pivotValue进行大小比较的 Y p o s [ h i g h = = l o w ] Y_{pos}[high == low] Ypos[high==low] 丢给 Y p o s [ l ] Y_{pos}[l] Ypos[l],将 p i v o t V a l u e pivotValue pivotValue插入到正确的位置 Y p o s [ h i g h ] Y_{pos}[high] Ypos[high]。
- 诶等等,一个不知道大小的值丢给左边不会错吗?所以说两句 w h i l e while while的顺序不能颠倒
while(Ypos[high] >= val && high > low) high--;
while(Ypos[low] <= val && high > low) low++;
- 注意到
s
w
a
p
(
Y
p
o
s
[
l
o
w
]
,
Y
p
o
s
[
h
i
g
h
]
)
swap(Y_{pos}[low],Y_{pos}[high])
swap(Ypos[low],Ypos[high])时,是在
l
o
w
<
h
i
g
h
low < high
low<high的情况下,找到一对儿不合适的位置进行交换的,这里我们将内层
w
h
i
l
e
while
while循环停下的位置称作不合适的位置。那么最终会出现一个可能不合适且匹配不到交换的位置
l
o
w
=
=
h
i
g
h
low == high
low==high,也就是循环终止的位置,我们能保证当前位置
Y
p
o
s
[
h
i
g
h
=
=
l
o
w
]
≤
p
i
v
o
t
V
a
l
u
e
Y_{pos}[high == low] \leq pivotValue
Ypos[high==low]≤pivotValue。下面分情况讨论
- C a s e 1 : Case\ 1: Case 1: l o w \ \ low low找到 h i g h high high,因为 h i g h high high指针先停到该位置所以满足条件 Y p o s [ h i g h ] < p i v o t V a l u e Y_{pos}[high] < pivotValue Ypos[high]<pivotValue。
- C a s e 2 : Case\ 2: Case 2: h i g h \ \ high high找到 l o w low low并且 l o w > l low > l low>l,可知 l o w low low一定停下来过,因此在上一层循环中一定有与之交换的另一个 h i g h high high,并且它们已经 s w a p swap swap。而在当前循环中 l o w low low还没有移动,实际上 Y p o s [ l o w ] Y_{pos}[low] Ypos[low]中的值是上一层循环中 Y p o s [ 上 一 个 h i g h ] Y_{pos}[上一个high] Ypos[上一个high],满足 Y p o s [ 上 一 个 h i g h ] < p i v o t V a l u e Y_{pos}[上一个high] < pivotValue Ypos[上一个high]<pivotValue。
-
C
a
s
e
3
:
Case\ 3:
Case 3:
h
i
g
h
\ \ high
high找到
l
o
w
low
low并且
l
o
w
=
=
l
low == l
low==l,枢轴量就是
l
l
l,显然满足
Y
p
o
s
[
h
i
g
h
=
=
l
o
w
]
=
=
p
i
v
o
t
V
a
l
u
e
Y_{pos}[high == low] == pivotValue
Ypos[high==low]==pivotValue。
综上,保证了最后循环终止的位置的值满足扔到左边去的条件,因此经典快排是没有错误的,嗯。
经典的局限性
经典算法好的不得了!但是它就是容易被卡,构造一组全部一样的数据,就能使得快排退化成 N 2 N^2 N2,问题仍然出在两个 w h i l e while while循环上。若数据全部一样,每次返回的 p i v o t pivot pivot都是 l l l,子问题分的太不均匀了,每次分治问题的规模只能减一。
while(Ypos[high] >= val && high > low) high--;
while(Ypos[low] <= val && high > low) low++;
无济于事的随机化
随机化快排,通过随机选择枢轴量 p i v o t pivot pivot来避免极差的情况,实现上是随机选择一个位置,然后把它放到 Y p o s [ l ] Y_{pos}[l] Ypos[l]里,然后套用经典算法即可。
int pivot = rand() % (r - l + 1) + l;
swap(Ypos[l],Ypos[pivot]);
在没搞明白之前,我还试图通过随机化来卡过全部一样的测试用例 (我是啥b) 。随机化在面对这种样例的时候完全无差,甚至还多了求随机数的时间。因为不管是否随机化,最终实际的枢轴量
p
i
v
o
t
pivot
pivot都是
l
l
l,从而陷入上方同样的局限性。在第一次
h
i
g
h
high
high左移的过程中,它会一路狂飚到
l
l
l的位置,使得问题的规模减一,完美。
着手点
其实快排关键就在于枢轴量位置的选择,在面对完全一样的用例时,明明能够左右分半,却非要一次移动到底。由此启发限制一次 w h i l e while while循环中 h i g h high high指针移动的长度,然后我对两个 w h i l e while while进行了一系列魔改。
while(Ypos[high] >= val && high > low) {
high--;
if(high > low && Ypos[low] <= val) low++;
} //后来放弃这个魔改了,太神必了而且WA了
while(Ypos[low] <= val && high > low) low++;
限制一次移动的长度不超过
H
a
l
f
l
e
n
Halflen
Halflen,那么刚才的最坏情况下现在变为右边移动一半,左边移动一半。我直接狂喜,
N
l
o
g
N
NlogN
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++;
抢救&进阶玩法
被
l
o
w
low
low和
h
i
g
h
high
high扫过的区间肯定是满足大小关系的,那么有问题的只能是可能没有跟
p
i
v
o
t
V
a
l
u
e
pivotValue
pivotValue进行大小比较的
Y
p
o
s
[
h
i
g
h
=
=
l
o
w
]
Y_{pos}[high == low]
Ypos[high==low],在魔改之后不能保证
Y
p
o
s
[
h
i
g
h
=
=
l
o
w
]
≤
p
i
v
o
t
V
a
l
u
e
Y_{pos}[high == low] \leq pivotValue
Ypos[high==low]≤pivotValue了,但是没有改变的是最终位置
h
i
g
h
=
=
l
o
w
high == low
high==low左边依旧是第一类数,右侧依然是第三类数。
为了正确的归类,在插回 p i v o t V a l u e pivotValue pivotValue之前加一条特判。如果 Y p o s [ h i g h = = l o w ] Y_{pos}[high == low] Ypos[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个 C a s e Case Case时候发现逻辑有点问题再次构思,写到早上7点,沃柑以后不熬夜写文章了,早知道打把游戏睡觉…