快速排序算法

2301_79761923

已于 2024-08-14 11:29:38 修改

阅读量733

点赞数 23

文章标签：算法 c++ 数据结构

于 2024-08-08 10:32:59 首次发布

本文链接：https://blog.csdn.net/2301_79761923/article/details/140990928

版权

一、题目

给定你一个长度为 n 的整数数列。请你使用快速排序对这个数列按照从小到大进行排序。并将排好序的数列按顺序输出。

输入格式

输入共两行，第一行包含整数 n。

第二行包含 n 个整数（所有整数均在 1∼ $10^{9}$ 范围内），表示整个数列。

输出格式

输出共一行，包含 n个整数，表示排好序的数列。

数据范围

1≤n≤100000

二、教材上的快排方法

#include<iostream>
using namespace std;
const int N=100;
int q[N];
void quicksort(int q[],int l,int r)
{
	int i = l, j = r, temp;
	if (l < r)//这一步也忘记了
	{
		temp = q[i];
		while (i < j)
		{
			while (i<j&&q[j] >= temp) j--;//这里的i<j不可省略
			q[i] = q[j];
			while (i<j&&q[i] <= temp) i++;
			q[j] = q[i];
		}
		q[i] = temp;
		quicksort(q, l, i - 1);
		quicksort(q, i + 1, r);
	}
}

int main()
{
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n ; i++) scanf("%d", &q[i]);
	quicksort(q, 0, n - 1);
	for (int i = 0; i < n; i++) printf("%d ", q[i]);
	return 0;
}

总结易错点：const 的用法写错，写quick函数时没加if判断句，写while函数时也忘记加了。

注：此解不适于该题目。

三、通用方法

#include<iostream>
using namespace std;
const int N=100100;
int q[N];
void quicksort(int q[],int l,int r)
{
    if(l>=r) return;
    int i=l-1,j=r+1,x=q[(l+r)/2];//x用这个更节省时间
    while(i<j)
    {
        do i++;while(q[i]<x);
        do j--;while(q[j]>x);
        if(i<j)swap(q[i],q[j]);
    }
    quicksort(q,l,j);
    quicksort(q,j+1,r);
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&q[i]);
    quicksort(q,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",q[i]);
    return 0;
}

其中难点

边界情况分析：快排属于分治算法，最怕的就是 n分成0和n，或 n分成n和0,这会造成无限划分

分析1

以j为划分时，x不能选q[r]

若以i为划分,则x不能选q[l]（这里取中间值是万能的）

假设 x = q[r]（以j为划分时）

关键句子quick_sort(q, l, j), quick_sort(q, j + 1, r);由于j的最小值是l,所以q[j+1..r]不会造成无限划分但q[l..j](即quick_sort(q, l, j))却可能造成无限划分，因为j可能取到r.
举例来说，若x选为q[r]，数组中q[l..r-1] < x,那么这一轮循环结束时i = r, j = r，显然会造成无限划分例如:4 2 1 3 5进行快排时，x=q[r],在quick(q,l,j),quick(q,j+1,r)循环结束时j=i=r.

分析2

do i++; while(q[i] < x)和do j--; while(q[j] > x) 中不能用q[i] <= x 和 q[j] >= x.

假设q[l..r]全相等

则执行完do i++; while(q[i] <= x);之后，i会自增到r+1.然后继续执行q[i] <= x 判断条件，造成数组下标越界(但这貌似不会报错)并且如果之后的q[i] <= x (此时i > r) 条件也不幸成立，就会造成一直循环下去(亲身实验)，造成内存超限(Memory Limit Exceeded),现在已经变成 Time Limit Exceeded 了.

分析3

if(i < j) swap(q[i], q[j])能否使用 i <= j

可以使用if(i <= j) swap(q[i], q[j]);因为 i = j 时，交换一下q[i],q[j] 无影响，因为马上就会跳出循环了

分析4

最后一句能否改用quick_sort(q, l, j-1), quick_sort(q, j, r)作为划分

与用i做划分时也是同样的道理

答案：不能

根据之前的证明，最后一轮循环可以得到这些结论

1.q[l..i-1] <= x, q[i] >= x
2.q[j+1..r] >= x, q[j] <= x
3.i >= j
所以，q[l..j-1] <= x 是显然成立的，但quick_sort(q, j, r)中的q[j] 却是 q[j] <= x，这不符合快排的要求。(循环结束时，i >= j,正常情况下，按照循环不变式，我们应该会觉得结果已经显然了.因为i >= j，q[l..i] <= x, q[j..r] >= x所以按照j来划分的话，q[l..j] <= x, q[j+1..r] >= x是显然的)另外一点，注意quick_sort(q, l, j-1), quick_sort(q, j, r)可能会造成无限划分。当x选为q[l]时会造成无限划分，报错为(MLE),如果手动改为 x = q[r],可以避免无限划分。

但是上面所说的q[j] <= x 的问题依然不能解决，这会造成 WA (Wrong Answer)

例如：在5 4 3 2 1中最后一轮排序（以x=q[l],j为划分）i,j均指向2(此时的顺序为14325）只有将0~j划分为一组即1432为一组才满足，所以只能是0~j.

分析5

j的取值范围为[l..r-1]

证明:
假设 j 最终的值为 r ,说明只有一轮循环(两轮的话 j 至少会自减两次)

说明q[r] <= x (因为要跳出do-while循环)

说明 i >= r(while循环的结束条件), i 为 r 或 r + 1(必不可能成立)

说明 i 自增到了 r , 说明 q[r] >= x 和 q[l..r-1] < x,

得出 q[r] = x 和 q[l..r-1] < x 的结论,但这与 x = q[l + r >> 1]矛盾

反证法得出 j < r
假设 j 可能小于 l 说明 q[l..r] > x ,矛盾

反证法得出 j >= l
所以 j的取值范围为[l..r-1],不会造成无限划分和数组越界

分析6

while(i < j) 能否改为 while(i <= j)

不能

while(i <= j) 意味着我们认为判断循环结束的条件为 i <= j.那么 if(i < j) 也要改为 if(i <= j).其实 if(i < j) 改不改都可以, 看完分析 6 后再参考分析 3 可以说明这一点.即

while(i <= j)
{
do i++; while(q[i] < x);
do j--; while(q[j] > x);
if(i <= j) swap(q[i], q[j]);
}
参考循环不变式的证明, 只有最后一轮循环有所不同,我们可以得到:

q[l..i-1] <= x, q[i] >= x

q[j+1..r] >= x, q[j] <= x

i > j

最终, 我们还能证明出 q[l..j] <= x,q[j+1..r] >= x.也就是说, while(i <= j) 并不会改变循环不变式的部分,但修改后的代码提交后却是 Time Limit Exceeded(TLE), 原因在于无限划分.具体来说, 就是 j 在某些情况下能取到 l-1, 此时就是无限划分.

q[l..r] 划分为 q[l..l-1], q[l..r]

某些情况指: 数组只有两个元素 [a, b] 且 a < b

这种情况下,初始 i = l - 1, j = r + 1

第一轮 while 循环结束 i = l, j = l

第二轮 while 循环结束 i = r, j = l-1

于是 while(i <= j) 就造成了无限划分, 而 while(i < j) 就不会造成这个问题, 因为第一轮 while 循环结束后就跳出去了.所以, 不能用 while(i <= j)

有些人可能会疑惑: 这种情况看起来比较极端啊, 如果构造数组 [3, 2, 1] 会不会就不会遇到这种情况了.其实不然, 因为快排是分治算法, 往下递归时总会遇到 [a, b], a < b 这种情况只要有一个这种情况, 就会进入无限划分出不来.只有在数组元素全相等情况下才遇不到这种情况, 此时算法就能正常运行了, 读者可自行验证

分析7

循环不变式证明过程中

do i++; while(q[i] < x);
会使得 q[l..i-1] <= x, q[i] >= x，其中会使得 q[l..i-1] <= x, q[i] >= x 能否改为会使得 q[l..i-1] < x, q[i] >= x

不能

这里的 q[l..i-1] <= x 是配合循环不变式 q[l..i] <= x q[j..r] >= x 的，于是问题就变成了循环不变式中 q[l..i] <= x 能否改为 q[l..i] < x，假定循环不变式是 q[l..i] < x, q[j..r] > x，执行两个 do-while 循环

do i++; while(q[i] < x);
会使得 q[l..i-1] < x, q[i] >= x

do j--; while(q[j] > x);
会使得 q[j+1..r] > x, q[j] <= x
则执行 if 语句后if(i < j) swap(q[i], q[j]);就会变成 q[l..i] <= x, q[j..r] >= x, 与假设矛盾

所以, 考虑最全面的描述还是要带上 = 的