快速排序的优化

最新推荐文章于 2022-02-20 18:55:40 发布
最新推荐文章于 2022-02-20 18:55:40 发布
阅读量373 收藏
点赞数 1
分类专栏： c++常见错误集锦

参考：http://blog.taoaili999.cn/2017/06/29/QuickSort-Optimization/

　快速排序的思想是分治法，当每次划分时，算法若都能分成两个等长的子序列时，那么分治算法效率会达到最大。所以基准枢纽元的选择是很重要，选择基准的方式决定了分割后两个子序列的长度，进而对整个算法的效率产生决定性影响。
　　通常实现的快速排序没有经过充分考虑的选择那个枢纽元，只是将第一个或最后一个元素用作枢纽元。选择第一个元素作为枢纽元的程序例子见快速排序的两种实现思路二,选择最后一个元素作为枢纽元的程序例子见快速排序的两种实现思路一

快速排序枢纽元选择的优化方法

方法一：随机选取枢纽元

　　如果输入序列是随机的，那么固定枢纽元为第一个或者最后一个这是可以接受的，但是如果输入是预排序的或者是反序的，那么固定枢纽元就产生一个劣质的分割，因为所有的元素不是被划入S1就是被划入S2。更有甚者，这种情况发生在所有的递归调用中。
　　实际上，如果第一个元素用作枢纽元而且输入是预先排序的，那么快速排序的时间复杂度为Θ(n^2)。然而，预排序的输入(或者有一大段预排序数据的输入)也是相当常见的，因此，使用第一个元素作为枢纽元的算法效率不是很高的。
　　随机选取枢纽元是相对安全的策略。由于枢轴的位置是随机的，那么产生的分割也不会总是会出现劣质的分割。在整个数组数字全相等时，仍然是最坏情况，时间复杂度是O(n^2）。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n）。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn）的期望时间复杂度。

　　随机选取枢纽元算法：

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

//随机选取枢纽元
int getRandomPivot(int low,int height)
{
	//主要是利用随机数，随机的获取数组中的一个元素做为主元
	int size = height - low + 1;
	int index = low + rand() % size;
	return index;
}
//随机枢纽元放到第一个元素的getPartition划分过程
int getPartitionOptimize1(vector<int> &nums, int low, int height)
{
	//主要是利用随机数，随机的获取数组中的一个元素做为枢纽元
	int index =getRandomPivot(low,height);
  
	swap(nums[low], nums[index]);//交换第一个元素和随机枢纽元
	int keyVal = nums[low];
	while (low<height)
	{
		while (low<height&&nums[height]>=keyVal)
		{
			height--;
		}
		nums[low] = nums[height];
		while (low<height&&nums[low]<=keyVal)
		{
			low++;
		}
		nums[height] = nums[low];
	}
	nums[low] = keyVal;
	return low;
}
//随机枢纽元放到最后一个元素的getPartition划分过程
int getPartitionOptimizer2(vector<int> &nums, int low, int height)
{
	//主要是利用随机数，随机的获取数组中的一个元素做为枢纽元
	int index =getRandomPivot(low,height);

	swap(nums[height], nums[index]);//交换最后一个元素和随机枢纽元
	int keyVal = nums[height];
	int i = low - 1;
	for (int j = low;j<height;j++)
	{
		if (nums[j]<=keyVal)
		{
			i = i + 1;
			swap(nums[j], nums[i]);
		}
	}
	swap(nums[i + 1], nums[height]);
	return i+1;
}

方法二：三数取中分割法选取枢纽元

　　虽然随机选取枢轴时，减少出现不好分割的几率，但是最坏情况下还是O(n^2），要缓解这种情况，就引入了三数取中选取枢纽，一组N个数的中值是第[N/2]个最大的数。枢纽元的最好的选择是数组的中值。可是，这很难算出来，并且会明显减慢快速排序的速度。这样的中值的估计可以通过随机选取三个元素并用它们的中值作为枢纽元而得到。事实上，随机性并没有多大的帮助，因此一般的做法是使用左端、右端和中心位置上的三个元素的中值作为枢纽元。显然使用三数中值分割法消除了预排序输入的不好情形。

　　三数取中分割法枢纽元算法：

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

//三数取中分割法:通过确定nums[low], nums[mid], nums[height]三者之中的那个第二大的元素为枢纽元时，便能尽最大限度保证快速排序算法不会出现O（N ^ 2）的最坏情况。。
void getMedianOfThreePivot(vector<int> &nums, int low, int height)
{
	//主要是利用三元区中值，随机的获取数组中的一个元素做为枢纽元
	int mid = (low + height) / 2;
	//首先把三元素中的最小的元素交换到中间
	if (nums[low] < nums[mid])
		swap(nums[low], nums[mid]);
	if (nums[height] < nums[mid])
		swap(nums[height], nums[mid]);
	//在比较两个较大的元素，把最小的放到最左边位置，即为三数中值
	if (nums[height] < nums[low])
		swap(nums[height], nums[low]);
}
//三数取中分割法枢纽元放到第一个元素的getPartition划分过程
int getPartitionOptimize1(vector<int> &nums, int low, int height)
{
	getMedianOfThreePivot(nums,low,height);//确定枢纽元

	int keyVal = nums[low];
	while (low < height)
	{
		while (low < height&&nums[height] >= keyVal)
		{
			height--;
		}
		nums[low] = nums[height];
		while (low < height&&nums[low] <= keyVal)
		{
			low++;
		}
		nums[height] = nums[low];
	}
	nums[low] = keyVal;
	return low;
}
//三数取中分割法枢纽元放到最后一个元素的getPartition划分过程
int getPartitionOptimizer4(vector<int> &nums, int low, int height)
{
	getMedianOfThreePivot(nums,low,height);//确定枢纽元

	int keyVal = nums[height];
	int i = low - 1;
	for (int j = low; j < height; j++)
	{
		if (nums[j] <= keyVal)
		{
			i = i + 1;
			swap(nums[j], nums[i]);
		}
	}
	swap(nums[i + 1], nums[height]);
	return i + 1;
}

枢纽元确定后递归快排函数优化方法

方法一：当待排序序列的长度分割到一定大小后，使用插入排序

　　对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到一定大小后，继续分割的效率比插入排序要差，此时可以使用插排而不是快排．截止范围：待排序序列长度N < 10，进行插入排序，而不是继续划分快排。

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

//利用插入排序优化
void insertSort(vector<int> &nums, int low, int height)
{
	for (int i = low; i <= height; i++)
	{
		int key = nums[i];
		int j = i - 1;
		while (j >= low && key < nums[j])
		{
			nums[j + 1] = nums[j];
			j--;
		}
		nums[j + 1] = key;
	}
}
//递归快排函数通过加入插入排序进行优化
void quickSortOptimize(vector<int> &nums, int low, int height) 
{
	if (height - low + 1 < 10)
	{
		insertSort(nums, low, height);
		return;
	}
	else
	{
		int mid = getPartitionOptimize1(nums, low, height);
		quickSort(nums, low, mid - 1);
		quickSort(nums, mid + 1, height);
	}
}

方法二：在一次分割结束后，可以把与枢纽元相等的元素聚在一起，继续下次分割时，不用再对与枢纽元相等元素分割

　举例：

1
2
3
4
5
6
7
8
9

举例：待排序序列 1 4 6 7 6 6 7 6 8 6
三数取中选取枢轴：下标为4的数6
转换后，待分割序列：6 4 6 7 1 6 7 6 8 6	
枢纽元key：6
本次划分后，未对与key元素相等处理的结果：1 4 6 6 7 6 7 6 8 6
下次的两个子序列为：1 4 6 和 7 6 7 6 8 6
本次划分后，对与key元素相等处理的结果：1 4 6 6 6 6 6 7 8 7
下次的两个子序列为：1 4 和 7 8 7
经过对比，我们可以看出，在一次划分后，把与key相等的元素聚在一起，能减少迭代次数，效率会提高不少

　具体实现过程分为两步：

1
2

第一步，在划分过程中，把与枢纽元key相等元素放入数组的两端
第二步，划分结束后，把与枢纽元key相等的元素移到枢纽元周围

　具体代码实现：

　　　枢纽元通过三数取中分割法后放在第一个元素，此法是从左右两边分别向中间靠拢，所以和枢纽元相等的值会出现在枢纽元左右两边，因此需要左右两边都进行相等枢纽元的聚集。

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

vector<int>  getPartitionGatherKey(vector<int> &nums, int low, int height)
{
	getMedianOfThreePivot(nums, low, height);//转换枢纽元
	int tmpLow = low;
	int tmpHeight = height;

	int left = low;
	int right = height;
	int leftCommonNum = 0;//记录左侧和枢纽元相等的元素个数
	int rightCommonNum = 0;//记录右侧和枢纽元相等的元素个数

	//第一步：划分的过程中把与枢纽元相等的元素分散到数组的两端
	int keyVal = nums[low];
	while (low < height)
	{
		while (low < height && nums[height] >= keyVal)
		{
			if (nums[height] == keyVal)
			{
				swap(nums[height], nums[right]);//相等元素放到右端
				--right;
				++rightCommonNum;
			}
			--height;
		}
		nums[low] = nums[height];
		while (low < height && nums[low] <= keyVal)
		{
			if (nums[low] == keyVal)
			{
				swap(nums[low], nums[left]);//相等元素放到左端
				++left;
				++leftCommonNum;
			}
			++low;
		}
		nums[height] = nums[low];
	}
	nums[low] = keyVal;

	//第二步：划分结束后，把与keyVal相等的元素移到枢纽轴（也就是枢纽元素）的两边
	for (int i = low -1,j = tmpLow;j < left;j++)
	{
		if (nums[i] != keyVal)
			swap(nums[j], nums[i]);
		--i;
	}
	for (int i = low + 1, j = tmpHeight; j > right; j--)
	{
		if (nums[i] != keyVal)
			swap(nums[j], nums[i]);
		++i;
	}
    //计算划分区域的索引
	int partitionLeftIndex = low - 1 - leftCommonNum;
	int partitionRighttIndex = low + 1 + rightCommonNum;
	vector<int> partitionIndex;
	partitionIndex.push_back(partitionLeftIndex);
	partitionIndex.push_back(partitionRighttIndex);

	return partitionIndex;
}
void quickSortGatherKey(vector<int> &nums, int low, int height)
{
	if (height - low + 1 < 10)
	{
		insertSort(nums, low, height);
		return;
	}
	else
	{
		vector<int> partitionIndex = getPartitionGatherKey(nums, low, height);
		quickSortGatherKey(nums, low, partitionIndex[0]);
		quickSortGatherKey(nums, partitionIndex[1], height);
	}
}

　　　枢纽元通过三数取中分割法后放在最后一个元素，此法枢纽元左边都是小于等于枢纽元的元素，右边都是大于枢纽元的元素，所以和枢纽元相等的值只会出现在枢纽元左两边，因此只需要左边进行相等枢纽元的聚集。

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

vector<int> getPartitionGatherKey(vector<int> &nums, int low, int height)
{
	getMedianOfThreePivot(nums, low, height);//
	swap(nums[height], nums[low]);//三数取中分割法后枢纽元在最左端，需放到最后一个元素处
	int tmpLow = low;
	int left = low;

	int leftCommonNum = 0;//记录左侧和枢纽元相等的元素个数
	
	//第一步：划分的过程中把与枢纽元相等的元素分散到数组的左端
	int keyVal = nums[height];
	int i = low - 1;
	for (int j = low; j < height; j++)
	{
		if (nums[j] <= keyVal)
		{
			i = i + 1;
			swap(nums[j], nums[i]);
			if (nums[i] == keyVal)
			{
				swap(nums[left], nums[i]);
				++left;
				++leftCommonNum;
			}
		}
	}
	swap(nums[i + 1], nums[height]);

	//第二步：划分结束后，把与keyVal相等的元素移到枢纽轴（也就是枢纽元素）的左边
	for (int k = i,j = tmpLow;j < left;j++)
	{
		if (nums[k] != keyVal)
		{
			swap(nums[k], nums[j]);
		}
		--k;
	}
	int partitionLeftIndex = i - leftCommonNum;
	int partitionRighttIndex = i + 2;
	vector<int> partitionIndex;
	partitionIndex.push_back(partitionLeftIndex);
	partitionIndex.push_back(partitionRighttIndex);
	return partitionIndex;
}
void quickSortGatherKey(vector<int> &nums, int low, int height)
{
	if (height - low + 1 < 10)
	{
		insertSort(nums, low, height);
		return;
	}
	else
	{
		vector<int> partitionIndex = getPartitionGatherKey(nums, low, height);
		quickSortGatherKey(nums, low, partitionIndex[0]);
		quickSortGatherKey(nums, partitionIndex[1], height);
	}
}

　　综上所述，以及对大量数据的测试可以得到最好的快排组合是：三数取中+插排+聚集相等元素,它和STL中的Sort函数效率差不多

快速排序优化的几种方法代码实现
09-15
快速排序是一种高效的排序算法...以上就是快速排序的几种优化方法，它们在不同的场景下能提升快速排序的效率和稳定性。通过这些优化，快速排序在实际应用中展现出强大的性能，成为许多编程语言内置排序函数的首选算法。
Java中快速排序的优化技巧：随机取样、三数取中和插入排序
m0_62468521的博客
09-10 1894
快速排序是一种高效的排序算法，通过选择基准元素，将数组分成两个子数组，并递归排序子数组，最终将它们合并。为了提高性能，可以采用随机取样、三数取中、插入排序等优化策略。
快速排序的几种常见实现及其性能对比
Sunshine的专栏
12-22 1万+
Hoare的变形版本（空穴法） 快速排序算法是一种不稳定的排序算法。其时间复杂度为O(nlogn)，最坏复杂度为O(n^2)；快排的空间复杂度为O(logn)，这个不确定正确。 假设待排序的数组为a[]，快速排序算法最常见的做法是将第一个元素设置为枢纽元。设置两个指针low和high，它们分别指向待排序的数组的低和高位： （1）high向左移动找小于枢纽的元素，找到后（找到的是a[high]
排序算法之快速排序
千里之行，始于足下
04-17 379
快速排序也属于交换排序，通过元素直接的比较和交换位置来达到排序的目的。 快速排序的思想是：在每一轮挑选一个基准元素，并让其他比它大的元素移动到数的一边，比它小的元素移动到数列的另一边，从而把数列拆解成两个部分。 这种思想就叫做分治法。
快速排序及优化方案
weixin_43899008的博客
02-20 6761
文章目录快速排序及其优化方案1. 快速排序的流程2. 快速排序的实现时间复杂度计算3. 快速排序优化随机获取基准值进行优化3.2二路快速排序原理：思想：4. 总结 快速排序及其优化方案 1. 快速排序的流程 首先设定一个分界值，通过该分界值将数组分成左右两部分。 将大于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边，而等于分分界值的部分放在相对中间的部分。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于分界值，相对中间的部分的的数据等于分界值。 然后，左边和右边的数据可以独立排序
快速排序的4种优化
Tyler_Zx的博客
09-15 5万+
快排思想 快排基准的选择 固定基准 随机基准 三数取中 快速排序的优化 优化1：序列长度达到一定大小时，使用插入排序 优化2：尾递归优化 优化3：聚集元素 优化4：多线程处理快排 快排思想 快排算法是基于分治策略的排序算法，其基本思想是，对于输入的数组a[low, high]，按以下三个步骤进行排序。 (1)分解：以a[...
快速排序优化
11-27
快速排序算法是当前使用最多的排序算法...优化排序算法：当快速排序的子序列的长度小于某个给定的K时，该子序列基本有序，采用插入排序算法对子序列进行优于快速排序算法，整体的算法时间复杂度下降为O(nk = nlg(n/k));
快速排序优化算法
11-24
Java语言的快速排序优化算法实现 算法思想： 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程...
有序序列进行快速排序优化测试样例
最新发布
03-30
有序序列进行快速排序优化测试样例
深入理解快速排序以及优化方式
x0919的博客
10-26 749
可能经常看面经的同学都知道，面试所遇到的排序算法，快速排序占主要位置，热度只增不减啊，其次就是归并和堆排序。 其实以前写过一篇排序的文章，写的比较简单，只是轻描淡写。今天我再次重新拿起笔，将快速排序的几大优化，再次一一讲述一遍。各位同学，读完这篇文章，如若对你能够带来一些感悟，记得给个大大的赞哦！！！ 前言 快速排序是在冒泡排序的基础之上，再次进行优化得来的。具体的步骤如下： 在待排序的序列中，选取一个数值，将大于它的数放到数组的右边，小于它的数放到数组的左边，等于它的数就放到数组的中间。 此时，相对于
SEO优化快速排名技术
02-02
用于网站的SEO优化学习，适合新手和刚入门的选手，是视频文件
百度关键词优化:SEO快速排名软件V 1.0
09-20
百度关键词优化软件V 1.0：3天让您的关键词冲向第一！(限关键词50名内)新用户可优化一个词！本软件是一款SEO优化软件。新增拟优化的关键词，并激活其中一个当前需优化的关键词。每天启动关键词优化一次，坚持一个月，您的关键词在引擎排名将逐步上升，并大幅提升网站流量。本优化软件第二版升级附带说明！
系统快速优化，简洁、快速.cmd
03-06
《系统快速优化，简洁、快速》是一个体积小见效快的系统垃圾清理工具。免安装，虽然没有优化大师的功能多样化，但是如果想把系统清得快而方便，用这个批处理小工具足矣！
深入理解快速排序（随机快排、双路快排、三路快排）
Frank的技术世界
07-01 7021
快速排序可以说是20世纪最伟大的算法之一了。相信都有所耳闻，它的速度也正如它的名字那样，是一个非常快的算法了。当然它也后期经过了不断的改进和优化，才被公认为是一个值得信任的非常优秀的算法。 本文将结合快速排序的三方面进行比较和深入解析。 快速排序 public class QuickSort { // 递归使用快速排序,对arr[l...r]的范围进行排序 publi...
数学之美番外篇：快排为什么那样快
热门推荐
刘未鹏|C++的罗浮宫
06-13 5万+
数学之美番外篇：快排为什么那样快  By 刘未鹏(pongba)C++的罗浮宫(http://blog.csdn.net/pongba)TopLanguage(http://groups.google.com/group/pongba) 目录0. 前言1. 猜数字2. 称球3. 排序    3.1 为什么堆排比快排慢    3.2 为什么快排其实也不
关于快排与随机化快排
weixin_34107955的博客
11-07 113
快排是我们比较熟悉的排序算法，时间复杂度最佳为O（nlogn）,最坏为O（n2）随机化快排只是通过换轴将产生最坏情况可能性降低 1 #include<stdio.h> 2 #include<math.h> 3 #include<stdlib.h> 4 #include<iostream> 5 #include<time.h&...
图片即时优化的三种简单解决方案
小影
09-23 1万+
本文要点 Web页面中的图片往往是页面加载缓慢的最主要原因； 图片优化很复杂，涉及大小调整、裁剪、格式转换及质量参数微调； 如今，有的云服务可以即时优化图片，极大地改善用户浏览包含图片的Web页面时的体验； 云服务提供了简单的API用于操作图片； 读者可以立即应用其中的一项服务，毫不费力地提升网站性能。 图片往往是导致页面加载缓慢的最主要原因。一些研究表明，以兆字节计的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值