导言
您是否真正的懂了快速排序，您是否已经能熟练地掌握快速排序？总得求知求真，所以，您，真的会了吗？
概念
快速排序（Quick sort），适用于Pascal，c++等语言。是对冒泡排序算法的一种改进。
步骤说明
- 首先设定一个分界值，通过该分界值将数组分成左右两部分。
- 将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。
- 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
- 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
逐步分析
（图片源于网络）
这是一张快速排序的模拟图。
STEP1
在图片中，我们可以发现：每次分界值的定义均来自给数据集的第一位，并且每当该数据集的数字个数小于等于1时，就不再进行分组。那么，我们就可以写出如下代码：
void qsort(int a[],int l,int r)
//a数组为需排序数组，boundary为分界值位置，l为该数据集的起始位置，r为终止位置
{
//STEP1
if(r<=l)//该数据集的数字个数小于等于1
{
return ;
}
int boundary=a[l];//更新分界值
}
STEP2
有了大体的框架，现在就只剩下分组和递归了。因为我们想让比分界值小的数都放在左边，其余的放在右边。所以我们可以定义 x , y x,y x,y 两个指针，一个从左向右找，一个从右向左找，直到 x ≥ y x≥y x≥y 为止。每次查找，我们都用一个 w h i l e while while 循环。一旦当前这个值大于 b o u n d a r y boundary boundary 或者这个值小于 b o u n d a r y boundary boundary，我们都退出循环。此时， x , y x,y x,y 都已经是不满足条件的了，我们将其调换位置。当然，如果 x , y x,y x,y 已经枚举至边缘，也要退出循环。所以呢，快速排序的基本代码就快完成了，如下：
void qsort(int a[],int l,int r)
//a数组为需排序数组，boundary为分界值位置，l为该数据集的起始位置，r为终止位置
{
//STEP1
if(r<=l)//该数据集的数字个数小于等于1
{
return ;
}
int boundary=a[l];//更新分界值
//STEP2
int x=l;
int y=r;//指针
while(1)//分组
{
while(a[x]<=boundary)//满足左数据集条件
{
x++;//继续查找
if(x==r)//查找至边界还没有
{
break;
}
}
while(a[y]>=boundary)//满足右数据集条件
{
y--;//继续查找
if(y==l)//查找至边界还没有
{
break;
}
}
if(x>=y)//左指针与右指针相重合或不满足条件
{
break;
}
int t=a[x];//交换位置
a[x]=a[y];
a[y]=t;
}
}
STEP3
最后的一步，也是最关键的一步。我们来想一想，在递归之前，我们需要做点什么：在STEP1里面，我们已经说过，我们定义的分界值是每一个数据集的第一位。但是，这个值，在左右组分好了之后，还是应该在最前面吗？不，它应该待在左右两组的中间。如何放在中间呢？我们只需要将中间值的位置与 y y y 调换一下。接下来，就是递归啦。我们分别递归左右两组即可。但是，在赋值的时候，千万要注意别把中间值的位置加进去！好了，快速排序的代码就这样完成了：
void qsort(int a[],int l,int r)
//a数组为需排序数组，boundary为分界值位置，l为该数据集的起始位置，r为终止位置
{
//STEP1
if(r<=l)//该数据集的数字个数小于等于1
{
return ;
}
int boundary=a[l];//定义分界值
//STEP2
int x=l;
int y=r;//指针
while(1)//分组
{
while(a[x]<=boundary)//满足左数据集条件
{
x++;//继续查找
if(x==r)//查找至边界还没有
{
break;
}
}
while(a[y]>=boundary)//满足右数据集条件
{
y--;//继续查找
if(y==l)//查找至边界还没有
{
break;
}
}
if(x>=y)//左指针与右指针相重合或不满足条件
{
break;
}
int t=a[x];//交换位置
a[x]=a[y];
a[y]=t;
}
int t=a[l];//中间值移动
a[l]=a[y];
a[y]=t;
qsort(a,l,y-1);//递归
qsort(a,y+1,r);
}
STEP4
如何调用这个函数呢？很简单，就像这样：qsort(数组名,起始位置,终止位置);
当然，这只是从小到大排序，如果想要从大到小排序，只需要改一下左右的分组就可以啦。
CODE
从小到大
void qsort(int a[],int l,int r)
{
if(r<=l)
{
return ;
}
int boundary=a[l];
int x=l;
int y=r;
while(1)
{
while(a[x]<=boundary)
{
x++;
if(x==r)
{
break;
}
}
while(a[y]>=boundary)
{
y--;
if(y==l)
{
break;
}
}
if(x>=y)
{
break;
}
int t=a[x];
a[x]=a[y];
a[y]=t;
}
int t=a[l];
a[l]=a[y];
a[y]=t;
qsort(a,l,y-1);
qsort(a,y+1,r);
}
从大到小
void qsort(int a[],int l,int r)
{
if(r<=l)
{
return ;
}
int boundary=a[l];
int x=l;
int y=r;
while(1)
{
while(a[x]>=boundary)
{
x++;
if(x==r)
{
break;
}
}
while(a[y]<=boundary)
{
y--;
if(y==l)
{
break;
}
}
if(x>=y)
{
break;
}
int t=a[x];
a[x]=a[y];
a[y]=t;
}
int t=a[l];
a[l]=a[y];
a[y]=t;
qsort(a,l,y-1);
qsort(a,y+1,r);
}
算法运用
1. [NOIP2006 普及组] 明明的随机数
分析
直接套模板就可以了。我们先将其去重，然后快速排序输出。
CODE
#include<bits/stdc++.h>
using namespace std;
void qsort(int a[],int l,int r)
{
if(r<=l)
{
return ;
}
int boundary=a[l];
int x=l;
int y=r;
while(1)
{
while(a[x]<=boundary)
{
x++;
if(x==r)
{
break;
}
}
while(a[y]>=boundary)
{
y--;
if(y==l)
{
break;
}
}
if(x>=y)
{
break;
}
int t=a[x];
a[x]=a[y];
a[y]=t;
}
int t=a[l];
a[l]=a[y];
a[y]=t;
qsort(a,l,y-1);
qsort(a,y+1,r);
}
int n;
int a[1000000];//输入的数
int b[1000000];//去重后的数
bool vis[1000000];//判断是否查询过
int idx;//去重以后数的个数
int main()
{
cin>>n;//输入
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
for(int i=1;i<=n;i++)//去重
{
if(vis[a[i]]==0)
{
vis[a[i]]=1;
b[++idx]=a[i];
}
}
qsort(b,1,idx);//排序
cout<<idx<<endl;//输出
for(int i=1;i<=idx;i++)
{
cout<<b[i]<<" ";
}
return 0;
}
2.母舰
分析
在做题之前，我们要知道几点：
- 每个攻击系统只能打一个防御系统，如果打完了就没有了。
- 我方的攻击系统的攻击力或者是敌方的防御系统的防御力是可能为 0 0 0 的。
- 为了造成最大伤害，我们要用尽量小的打他的防御系统，因为大的要放后面打母舰。
这就是一种贪心的思路，我们直接照着做就行了。
CODE
#include<bits/stdc++.h>
using namespace std;
void qsort(int a[],int l,int r)
{
if(r<=l)
{
return ;
}
int boundary=a[l];
int x=l;
int y=r;
while(1)
{
while(a[x]<=boundary)
{
x++;
if(x==r)
{
break;
}
}
while(a[y]>=boundary)
{
y--;
if(y==l)
{
break;
}
}
if(x>=y)
{
break;
}
int t=a[x];
a[x]=a[y];
a[y]=t;
}
int t=a[l];
a[l]=a[y];
a[y]=t;
qsort(a,l,y-1);
qsort(a,y+1,r);
}
int a[10000000],b[10000000];//a表示我方，b表示敌方
int m,n;
int ans;
int main()
{
cin>>m>>n;
for(int i=1;i<=m;i++)
{
cin>>b[i];
}
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
qsort(b,1,m);//从小到大排序
qsort(a,1,n);
int k=1;
for(int i=1;i<=n;i++)
{
if(b[k]==0)//没有防御力
{
k++;
}
if(b[k]<a[i]&&b[k]!=0)//能打
{
a[i]=0;
k++;
}
}
if(k<=m)//没打完
{
cout<<0;
return 0;
}
for(int i=1;i<=n;i++)
{
ans+=a[i];//累加
}
cout<<ans;//输出
return 0;
}
可是，它 T L E TLE TLE 了。这是为什么呢？因为这个递归的过程有点慢，需要优化。至于如何优化，我就不说了，可以自己想想。我在这里说一个更简单的方法。
众所不一定周知，在C++里，有一个神奇的东西，叫做
S
T
L
STL
STL。（不知道的戳这里）而在
S
T
L
STL
STL 里，又有一个叫做
s
o
r
t
sort
sort 的排序工具，就像套用函数一样，我们可以直接在主函数里写 sort(数组名+起始下标,数组名+终止下标,cmp)，注意，这个
c
m
p
cmp
cmp 是可以不加的。如果不加，就默认是从小到大排序。至于
c
m
p
cmp
cmp 怎么写，请看下面代码：
bool cmp(int x,int y)//cmp是个函数
{
return x>y;//>表示从大到小，这里可以加其它判断符
}
在编程的时候，如果可以，尽量用更快捷的排序算法，以保证正确性的提高。（在思路正确的情况下）
总结
快速排序其实很容易理解，就是一种像分治一样的算法。如果快速排序真的掌握了，那么 A C AC AC这道题也是轻轻松松（bushi
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
