快速排序

最新推荐文章于 2024-09-12 15:56:42 发布

SNAKEpc12138

最新推荐文章于 2024-09-12 15:56:42 发布

阅读量203

点赞数

分类专栏：排序算法文章标签：快速排序 C++ 时间复杂度递归不稳定算法

本文链接：https://blog.csdn.net/SNAKEpc12138/article/details/116426095

版权

排序算法专栏收录该内容

7 篇文章 0 订阅

订阅专栏

基本思想

快速排序(QuickSort)的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

一般流程

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

C++代码

递归三部曲：

确定递归函数的返回值和参数列表。因为要对序列排序，所以参数需要原序列的引用以及序列起始终止位置。
递归终止条件。这个及其重要，用来返回上层递归，没有则会无限递归下去！！！
单层递归逻辑。即递归函数的作用，这里每次递归都是一次排序，即将传入的起始终止位置的序列以key为分界线划分成左右两个部分。

//快速排序
//左闭右闭区间
void quickSort(vector<int>& v, int begin, int end)
{
	//递归终止条件
	if (begin >= end) return;
	
	//下面是单层递归逻辑部分：将begin为起始位置end为终止位置的v以key为分界线划分成左右两个序列，然后继续左右序列的递归排序。
	int i = begin, j = end;
	int key = v[i];
	while (i < j)
	{
		while (i < end && v[j] > key)
		{
			j--;
		}
		v[i] = v[j];
		while (i < j && v[i] <= key)
		{
			i++;
		}
		v[j] = v[i];
	}
	//退出循环begin == end
	v[i] = key;
	//之后递归该位置右左区间排序，始终坚持左闭右闭区间
	quickSort(v, begin, i - 1);
	quickSort(v, i + 1, end);
}

int main
{
	vector<int> v{ 2, 2, 5, 1, 3 };
	cout << "排序前：" << endl;
	for (int x : v)
	{
		cout << x << " ";
	}
	cout << endl;
	cout << "-------------------------------------------\n";
	//快速排序测试
	quickSort(v, 0, 4);
	cout << "排序后：" << endl;
	for (int x : v)
	{
		cout << x << " ";
	}
	cout << endl;
	cout << "-------------------------------------------\n";
	return 0;
}

测试结果

排序过程

依旧以[2, 2, 5, 1, 3]为例，主要黑色加粗的2，用来判断算法的稳定性。

第一轮排序，即第一次递归调用。
key = 2, i = begin = 0, j = end = 4
①i = 0 < j = 4 && v[j] = 3 > key，j–，i不变。
②i = 0 < j = 3 && v[j] = 1 < key, 交换，v[j] = v[i], i++, j不变
③i = 1 < j = 3 && v[i] = 2 <= key, i++, j不变
④i = 2 < j = 3 && v[i] = 5 > key, 交换，v[j] = v[j], j–, i不变
⑤i = 2 == j =2, 退出循环，v[i] = key, 该轮排序结束。
比较次数n - 1次，时间复杂度为O(n)。其中n为给定区间的元素个数。
得到第一轮排序的结果, 以key = 2为分界线划分的左右序列[1, 2, 2, 5, 3]。

然后对左序列进行递归排序quickSort(v, begin, i - 1);
第二轮排序，key = 1, i = begin = 0, j = end = 1
①i = 0 < j = 1 && v[j] = 2 >= key, j–, i不变。
②i = 0 == j = 0, 退出循环，v[i] = key = 1，该轮排序结束，因为该轮排序中给定的序列只有两个元素，所以再次递归会直接返回，因此左递归排序结束。
比较次数为n - 1, 时间复杂度为O(n), 其中n 为给定区间中的元素个数。
左递归的排序结果[1, 2, 2, 5, 3]

之后进行右序列递归排序quickSort(v, i + 1, end);
第三轮排序，key = 5, i = begin = 3, j = end = 4。
①i = 3 < j = 4 && v[j] < key, 交换，v[i] = v[j] = 3, i++, j 不变
②i = 4 == j = 4, 退出循环，v[i] = key = 5，该轮排序结束，同上右递归排序结束。
比较次数为n - 1, 时间复杂度为O(n)。
右递归的排序结果为[1, 2, 2, 3, 5]

左右递归结束，整体排序结束。最终结果为[1, 2, 2, 3, 5]。

时间复杂度

快速排序的一次划分算法从两头交替搜索，直到begin和end重合，因此其时间复杂度是O(n)；而整个快速排序算法的时间复杂度与划分的趟数有关。

最好情况：
每次划分所选择的中间数（即key）恰好将当前序列几乎等分，经过log2n趟划分，便可得到长度为1的子表。

上例中第一趟划分中，key = 2，正好将序列等分成左序列[1, 2] 和右序列[5, 3]。
然后左递归划分，key = 1，将序列划分成左子序列[] 和右子序列[2]。
右递归划分同理得到左子序列[3] 和右子序列[]。

即第一次划分后将当前序列等分，所有后序只需进行log2n次，即log2(4) = 2次划分，便可得到长度<= 1的子序列。

这样，整个算法的最好时间复杂度为O(nlog2n)。

最坏情况：
每次所选的中间数是当前序列中的最大或最小元素，这使得每次划分所得的子表（左子序列或右子序列）中一个为空表，另一子表的长度为原表的长度-1（n - 1）。这样，长度为n的数据表的快速排序需要经过n趟划分，使得整个排序算法的时间复杂度为O(n*n) , 即最坏时间复杂度为O(n²)。

平均时间复杂度为O(nlog2n)。