基础算法 第六课——快速排序（回顾）

导言

您是否真正的懂了快速排序，您是否已经能熟练地掌握快速排序？总得求知求真，所以，您，真的会了吗？

概念

快速排序（Quick sort），适用于Pascal，c++等语言。是对冒泡排序算法的一种改进。

步骤说明

1. 首先设定一个分界值，通过该分界值将数组分成左右两部分。
2. 将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。
3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

逐步分析

（图片源于网络）

这是一张快速排序的模拟图。

STEP1

在图片中，我们可以发现：每次分界值的定义均来自给数据集的第一位，并且每当该数据集的数字个数小于等于1时，就不再进行分组。那么，我们就可以写出如下代码：

void qsort(int a[],int l,int r)
//a数组为需排序数组，boundary为分界值位置，l为该数据集的起始位置，r为终止位置
{
	//STEP1
	if(r<=l)//该数据集的数字个数小于等于1
	{
		return ;
	}
	
	int boundary=a[l];//更新分界值
}
1
2
3
4
5
6
7
8
9
10
11

STEP2

有了大体的框架，现在就只剩下分组和递归了。因为我们想让比分界值小的数都放在左边，其余的放在右边。所以我们可以定义 $x,y$ 两个指针，一个从左向右找，一个从右向左找，直到 $x\ge y$ 为止。每次查找，我们都用一个 $while$ 循环。一旦当前这个值大于 $boundary$ 或者这个值小于 $boundary$，我们都退出循环。此时，$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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

STEP3

最后的一步，也是最关键的一步。我们来想一想，在递归之前，我们需要做点什么：在STEP1里面，我们已经说过，我们定义的分界值是每一个数据集的第一位。但是，这个值，在左右组分好了之后，还是应该在最前面吗？不，它应该待在左右两组的中间。如何放在中间呢？我们只需要将中间值的位置与 $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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

从大到小

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

算法运用

1. [NOIP2006 普及组] 明明的随机数

link

分析

直接套模板就可以了。我们先将其去重，然后快速排序输出。

CODE

#include
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

2.母舰

link

分析

在做题之前，我们要知道几点：

1. 每个攻击系统只能打一个防御系统，如果打完了就没有了。
2. 我方的攻击系统的攻击力或者是敌方的防御系统的防御力是可能为 $0$ 的。
3. 为了造成最大伤害，我们要用尽量小的打他的防御系统，因为大的要放后面打母舰。

这就是一种贪心的思路，我们直接照着做就行了。

CODE

#include
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

可是，它 $TLE$ 了。这是为什么呢？因为这个递归的过程有点慢，需要优化。至于如何优化，我就不说了，可以自己想想。我在这里说一个更简单的方法。

众所不一定周知，在C++里，有一个神奇的东西，叫做 $STL$。（不知道的戳这里）而在 $STL$ 里，又有一个叫做 $sort$ 的排序工具，就像套用函数一样，我们可以直接在主函数里写 sort(数组名+起始下标,数组名+终止下标,cmp)，注意，这个 $cmp$ 是可以不加的。如果不加，就默认是从小到大排序。至于 $cmp$ 怎么写，请看下面代码：

bool cmp(int x,int y)//cmp是个函数
{
	return x>y;//>表示从大到小，这里可以加其它判断符
}
1
2
3
4

在编程的时候，如果可以，尽量用更快捷的排序算法，以保证正确性的提高。（在思路正确的情况下）

总结

快速排序其实很容易理解，就是一种像分治一样的算法。如果快速排序真的掌握了，那么 $AC$这道题也是轻轻松松（bushi