devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

[数据结构 -- 手撕排序算法第六篇] 递归实现快速排序（集霍尔版本，挖坑法，前后指针法为一篇的实现方法，很能打）_hoare版本 2、挖坑法 3、前后指针法

作者：IT小白 | 2024-04-27 22:26:16

赞

踩

hoare版本 2、挖坑法 3、前后指针法

目录

1、常见的排序算法

1.1 交换排序基本思想

2、快速排序的实现方法

2.1 基本思想

3 hoare（霍尔）版本

3.1 实现思路

3.2 思路图解

3.3 为什么实现思路的步骤2、3不能交换

3.4 hoare版本代码实现

3.5 hoare版本代码测试

4、挖坑法

4.1 实现思路

4.2 思路图解

4.3 挖坑法代码实现

4.4 挖坑法代码测试

5、前后指针版本

5.1 实现思路

5.2 思路图解

5.3 前后指针法代码实现

5.4 前后指针法代码测试

6、时间复杂度分析

6.1 最好情况

6.2 最坏情况

7、优化快速排序

7.1 选 key 优化

7.2 小区间优化

1、常见的排序算法

1.1 交换排序基本思想

冒泡排序属于交换排序之一，我们先来了解以下冒泡排序思想。

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

2、快速排序的实现方法

递归实现与二叉树的前序遍历很相似，将区间划分为左右两半部分的常见方式有三种：1.hoare版本；2.挖坑法；3.左右指针法。

2.1 基本思想

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中
的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右
子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止 。

所以，在后面很重要的一点就是，左边走找小，右边走找大。

3 hoare（霍尔）版本

3.1 实现思路

我们规定排升序，排序数组名称为a，基准值 key，基准值下标 keyi，左 left，右 right。

1.选出一个key，key可以是需要排序的数组中任意一个元素，我们本篇文章选key为a[left]；

2.从数组右端（尾部）往左走，当a[right] < key(a[keyi])，right停下来；

3.然后从数组左端（首部）往右走，当a[left] > key(a[keyi])，left停下来；

4.交换a[left], a[right]；

5.循环步骤2、3、4，当 left与right 走到相同位置时，交换此位置的元素与 key，key 的位置就确定了。

6.此时 key 就将数组分为了左右两个区间，我们对左右两个区间分别使用前5步，然后再次确定了左右区间的key，递归左区间，再递归右区间，就实现了排序。

注意：步骤2、3的顺序不能换。至于为什么，我们思路图解后再说。

3.2 思路图解

我们的图解就是按照实现思路来画的。

3.3 为什么实现思路的步骤2、3不能交换

我们可以看到，思路图解里，当最后找到 3 时候是 R 先走，R先遇到 3，如果是 L 先走，左找大，L 遇见 3 不会停下来，会直接走到R的位置，R 位置是 9，这时候相遇，就交换，一旦交换，左区间就不是全部小于 key（6）了，这就会出现错误。因此，key 如果选在左边，右边先走。

Q：hoare版本我们是理解了，如果key选在右边，那是不是左边先走呢？

A：答案是一定的。这里其实就是 L遇到R 还是 R遇到L 的问题。我们依然可以用上面的解法来想这问题，当L遇到R 时，说明 R 已经停下，R 停下就是 a[right]<key，这时 L遇到R，相遇位置就是小于 key 的位置，交换（key，a[left]），这时最后一个小于 key 的元素就放在了最左边，而 key 就到了确定的位置，不用再调了，以key 为中点的左区间全部小于 key，右区间全大于 key；

key在右边，当 R遇到L 时，说明 L 已经停下，L 停下就是 a[left]>key，这时 R遇到L，相遇位置就是大于 key 的位置，交换（a[left]，key），这时最后一个大于 key 的元素就放在了最右边，而 key 就到了确定的位置，不用再调了，以 key 为中点的左区间全部小于 key，右区间全大于 key。

所以如果 key 选在左边，就先走右边；key 选在右边，就先走左边。

3.4 hoare版本代码实现

  1. // 快速排序hoare版本
  2. int PartSort1(int* a, int left, int right)
  3. {
  4. 	int keyi = left;
  5. 	while (left < right)
  6. 	{
  7. 		//右边找小
  8. 		while (left < right && a[right] >= a[keyi])
  9. 		{
  10. 			right--;
  11. 		}
  12. 		//左边找大
  13. 		while (left < right && a[left] <= a[keyi])
  14. 		{
  15. 			left++;
  16. 		}
  17. 		Swap(&a[left], &a[right]);
  18. 	}
  19. 	Swap(&a[keyi], &a[left]);
  20.  
  21. 	return left;
  22. }
  23. void QuickSort(int* a, int left, int right)
  24. {
  25. 	if (left >= right)
  26. 		return;
  27.  
  28. 	int keyi = PartSort1(a, left, right);
  29. 	QuickSort(a, left, keyi - 1);
  30. 	QuickSort(a, keyi + 1, right);
  31. }
 

3.5 hoare版本代码测试
 

  1. void Swap(int* p1, int* p2)
  2. {
  3. 	int tmp = *p1;
  4. 	*p1 = *p2;
  5. 	*p2 = tmp;
  6. }
  7. void Print(int* a, int n)
  8. {
  9. 	for (int i = 0; i < n; i++)
  10. 	{
  11. 		printf("%d ", a[i]);
  12. 	}
  13. 	printf("\n");
  14. }
  15.  //快速排序递归实现
  16.  //快速排序hoare版本
  17. int PartSort1(int* a, int left, int right)
  18. {
  19. 	int keyi = left;
  20. 	while (left < right)
  21. 	{
  22. 		//右边找小
  23. 		while (left < right && a[right] >= a[keyi])
  24. 		{
  25. 			right--;
  26. 		}
  27. 		//左边找大
  28. 		while (left < right && a[left] <= a[keyi])
  29. 		{
  30. 			left++;
  31. 		}
  32. 		Swap(&a[left], &a[right]);
  33. 	}
  34. 	Swap(&a[left], &a[keyi]);
  35. 	return left;
  36. }
  37. void QuickSort(int* a, int left, int right)
  38. {
  39. 	if (left >= right)
  40. 		return;
  41.  
  42. 	int keyi = PartSort1(a, left, right);
  43. 	QuickSort(a, left, keyi - 1);
  44. 	QuickSort(a, keyi + 1, right);
  45. }
  46. void test()
  47. {
  48. 	int a[] = { 6,3,2,1,5,7,9 };
  49. 	QuickSort(&a, 0, sizeof(a) / sizeof(int) - 1);
  50. 	Print(&a, sizeof(a) / sizeof(int));
  51. }
  52. int main()
  53. {
  54. 	test();
  55.  
  56. 	return 0;
  57. }
 

 

4、挖坑法
 

4.1 实现思路
 

我们规定排升序，排序数组名称为a，基准值 key，左 left，右 right。
 

 
 
1.选出一个key，key可以是需要排序的数组中任意一个元素，我们依然选key为a[left]，将a[left]交给key保存起来，被选为key的元素位置就是坑位；
 
 
2.从数组右端（尾部）往左走，当a[right] < key，right停下来，将a[right]放到坑位中，坑位就换为下标为 right 的位置，此时right不动；
 
 
3.然后从数组左端（首部）往右走，当a[left] > key，left停下来，将a[left]放到坑位中，坑位就换为下标为 left 的位置，此时left不动；
 
 
4.循环步骤2、3，当 left与right 走到相同位置时，这个位置就是最后一个坑位，将key放到这个坑位中，key的最终位置就确定下来了，后面就不用再调整了。
 
 
5.此时 key 就将数组分为了左右两个区间，我们对左右两个区间分别使用前4步，然后再次确定了左右区间的key，递归左区间，再递归右区间，就实现了排序。
 

 

挖坑法与hoare版本的区别：
 

 
 
1.挖坑法不需要去想最后的 L与R 相遇的位置的元素要小于key，因为最终相遇位置是坑位，直接将 key 放入坑位就好了；
 
 
2.不用去想为什么选左边为 key 要右边先走，选右边为 key 要左边先走，当选左边为 key 时，因为需要填左边的坑，所以肯定是右边先走。左边找小，右边找大来理解这句话更合适。
 

 

4.2 思路图解
 

 

 

4.3 挖坑法代码实现
 

  1. // 快速排序挖坑法
  2. int PartSort2(int* a, int left, int right)
  3. {
  4. 	int key = a[left];
  5. 	int hole = left;
  6. 	while (left < right)
  7. 	{
  8. 		//右边找小
  9. 		while (left < right && a[right] >= key)
  10. 		{
  11. 			right--;
  12. 		}
  13. 		a[hole] = a[right];
  14. 		hole = right;
  15.  
  16. 		//左边找大
  17. 		while (left < right && a[left] <= key)
  18. 		{
  19. 			left++;
  20. 		}
  21. 		a[hole] = a[left];
  22. 		hole = left;
  23. 	}
  24. 	a[hole] = key;
  25.  
  26. 	return hole;
  27. }
  28. void QuickSort(int* a, int left, int right)
  29. {
  30. 	if (left >= right)
  31. 		return;
  32.  
  33. 	int keyi = PartSort2(a, left, right);
  34. 	QuickSort(a, left, keyi - 1);
  35. 	QuickSort(a, keyi + 1, right);
  36. }
 

4.4 挖坑法代码测试
 

  1. void Swap(int* p1, int* p2)
  2. {
  3. 	int tmp = *p1;
  4. 	*p1 = *p2;
  5. 	*p2 = tmp;
  6. }
  7. void Print(int* a, int n)
  8. {
  9. 	for (int i = 0; i < n; i++)
  10. 	{
  11. 		printf("%d ", a[i]);
  12. 	}
  13. 	printf("\n");
  14. }
  15. // 快速排序挖坑法
  16. int PartSort2(int* a, int left, int right)
  17. {
  18. 	int key = a[left];
  19. 	int hole = left;
  20. 	while (left < right)
  21. 	{
  22. 		//右边找小
  23. 		while (left < right && a[right] >= key)
  24. 		{
  25. 			right--;
  26. 		}
  27. 		a[hole] = a[right];
  28. 		hole = right;
  29.  
  30. 		//左边找大
  31. 		while (left < right && a[left] <= key)
  32. 		{
  33. 			left++;
  34. 		}
  35. 		a[hole] = a[left];
  36. 		hole = left;
  37. 	}
  38. 	a[hole] = key;
  39.  
  40. 	return hole;
  41. }
  42. void QuickSort(int* a, int left, int right)
  43. {
  44. 	if (left >= right)
  45. 		return;
  46.  
  47. 	int keyi = PartSort2(a, left, right);
  48. 	QuickSort(a, left, keyi - 1);
  49. 	QuickSort(a, keyi + 1, right);
  50. }
  51. void test()
  52. {
  53. 	int a[] = { 6,3,2,1,5,7,9 };
  54. 	QuickSort(&a, 0, sizeof(a) / sizeof(int) - 1);
  55. 	Print(&a, sizeof(a) / sizeof(int));
  56. }
  57. int main()
  58. {
  59. 	test();
  60.  
  61. 	return 0;
  62. }
 

 

5、前后指针版本
 

5.1 实现思路
 

我们规定排升序，排序数组名称为a，基准值 key。
 

 
 
1.选出一个key，key可以是需要排序的数组中任意一个元素，我们依然选key为a[left]；
 
 
2.定义一个prev指针，和一个cur指针，初始化 prev 指向数组首部位置，cur 指向 prev 的下一个位置。cur先走，cur 找小于 key 的元素，找到之后停下来，让 prev++，然后交换 (a[cur], a[prev])。交换完继续往后走，cur 找的值不小于 key，cur继续往后走，找到后让 prev++，交换 (a[cur], a[prev])，不断重复此步骤；
 
 
3.当cur走完整个数组的时候，交换(a[left], a[prev])，这时key的最终位置就确定下来了。key 将数组分为左右两个子区间，左子区间小于 key，右子区间大于 key；
 
 
4.左右子区间继续重复前 3 步骤，递归下去就实现了数组的排序。
 

 

5.2 思路图解
 

 

这里不断交换其实是将小于 key 的值一直在往前抛，把大于 key 的值往后抛，cur与prev 之间的值其实就是大于 key 的所有值，不断交换就实现了最终以 key 划分的左右区间，左区间小于 key，右区间大于 key。
 

5.3 前后指针法代码实现
 

  1. // 快速排序前后指针法
  2. int PartSort3(int* a, int left, int right)
  3. {
  4. 	int prev = left;
  5. 	int cur = left + 1;
  6. 	int keyi = left;
  7. 	while (cur <= right)
  8. 	{
  9. 		if (a[cur] < a[keyi] && ++prev != cur)
  10. 		{
  11. 			Swap(&a[prev], &a[cur]);
  12. 		}
  13.  
  14. 		cur++;
  15. 	}
  16. 	Swap(&a[keyi], &a[prev]);
  17. 	return prev;
  18. }
  19. void QuickSort(int* a, int left, int right)
  20. {
  21. 	if (left >= right)
  22. 		return;
  23.  
  24. 	int keyi = PartSort3(a, left, right);
  25. 	QuickSort(a, left, keyi - 1);
  26. 	QuickSort(a, keyi + 1, right);
  27. }
 

5.4 前后指针法代码测试
 

  1. // 快速排序前后指针法
  2. int PartSort3(int* a, int left, int right)
  3. {
  4. 	int prev = left;
  5. 	int cur = left + 1;
  6. 	int keyi = left;
  7. 	while (cur <= right)
  8. 	{
  9. 		if (a[cur] < a[keyi] && ++prev != cur)
  10. 		{
  11. 			Swap(&a[prev], &a[cur]);
  12. 		}
  13.  
  14. 		cur++;
  15. 	}
  16. 	Swap(&a[keyi], &a[prev]);
  17. 	return prev;
  18. }
  19. void QuickSort(int* a, int left, int right)
  20. {
  21. 	if (left >= right)
  22. 		return;
  23.  
  24. 	int keyi = PartSort3(a, left, right);
  25. 	QuickSort(a, left, keyi - 1);
  26. 	QuickSort(a, keyi + 1, right);
  27. }
  28. void test()
  29. {
  30. 	int a[] = { 6,3,2,1,5,7,9 };
  31. 	QuickSort(&a, 0, sizeof(a) / sizeof(int) - 1);
  32. 	Print(&a, sizeof(a) / sizeof(int));
  33. }
  34. int main()
  35. {
  36. 	test();
  37.  
  38. 	return 0;
  39. }
 

 

 

6、时间复杂度分析
 

6.1 最好情况
 

上面的三种情况下，最好情况时间复杂度是O(N* logN)。
 

每次 key 被排到区间的中间位置，像二叉树一样要递归 logN 次，每一次的子区间排序的时间复杂度是O(N)，所以最好的情况就是O(N * logN)。
 

 

 

6.2 最坏情况
 

当数组有序的时候排序，无论 key 选最左边还是最右边，时间复杂度都是O(N^2)。
 

 

 

7、优化快速排序
 

 
 
快速排序的优化有两种思想：
 
 
1.我们对选key法可以进行优化；
 
 
2.递归到小的子区间，我们可以考虑使用插入排序，也称小区间优化。
 

 

7.1 选 key 优化
 

选 key 优化主要是针对数组有序，或者是接近有序。
 

 
 
对选 key 的优化我们有两种思路：
 
 
1.随机选 key；
 
 
2.三数取中选 key。（拿出left, mid, right，在下标为这三个位置的数中选出一个中间值作为 key）。
 

 

第一种思路是不可控的，所以第二种选 key 的思路才是最合适的。
 

下面是三数取中的优化代码：
 

  1. int GetMidIndex(int* a, int left, int right)
  2. {
  3. 	int mid = (left + right) / 2;
  4. 	if (a[left] < a[mid])
  5. 	{
  6. 		if (a[mid] < a[right])
  7. 			return mid;
  8. 		else if (a[left] < a[right])
  9. 			return right;
  10. 		else
  11. 			return left;
  12. 	}
  13. 	else //a[left] > a[mid]
  14. 	{
  15. 		if (a[mid] > a[right])
  16. 			return mid;
  17. 		else if (a[left] > a[right])
  18. 			return right;
  19. 		else
  20. 			return left;
  21. 	}
  22. }
  23. int PartSort3(int* a, int left, int right)
  24. {
  25. 	int midi = GetMidIndex(a, left, right);
  26. 	Swap(&a[left], &a[midi]);
  27.  
  28. 	int prev = left;
  29. 	int cur = left + 1;
  30. 	int keyi = left;
  31. 	while (cur <= right)
  32. 	{
  33. 		if (a[cur] < a[keyi] && ++prev != cur)
  34. 		{
  35. 			Swap(&a[prev], &a[cur]);
  36. 		}
  37. 		cur++;
  38. 	}
  39. 	Swap(&a[prev], &a[keyi]);
  40. 	keyi = prev;
  41. 	return keyi;
  42. }
 

我们取到中后，将该数字与 a[left]交换，依旧用之前的前后指针法的思路是没有问题的。霍尔版本与挖坑法是一样的优化方法。
 

如果我们不做三数取中的优化，当数组是有序或者接近有序的时候，时间复杂度会是最坏情况，O(N^2)。经过三数取中后，如果数组是有序的，时间复杂度仍是O(N * logN)。
 

7.2 小区间优化
 

 
 
在递归的时候，我们之前画的图中不难看到，在不断的划分的时候，到后面划分的越来越多了，当数据量特别大的时候，对栈的消耗会很大，会造成栈溢出的风险。因此，当划分到一定的程度，我们不再划分，直接选择插入排序。一般的情况下，当我们的子区间数据个数为10的时候，我们就不再递归了，直接就用插入排序。
 

 

 

 

实现代码：
 

  1. // 插入排序
  2. //时间复杂度（最坏）：O(N^2) -- 逆序
  3. //时间复杂度（最好）：O(N) -- 顺序
  4. void InsertSort(int* a, int n)
  5. {
  6. 	for (int i = 0; i < n - 1; i++)
  7. 	{
  8. 		int end = i;
  9. 		int tmp = a[i + 1];
  10. 		
  11. 		while (end >= 0)
  12. 		{
  13. 			if (a[end] > tmp)
  14. 			{
  15. 				a[end + 1] = a[end];
  16. 				end--;
  17. 			}
  18. 			else
  19. 			{
  20. 				break;
  21. 			}
  22. 		}
  23. 		a[end + 1] = tmp;
  24. 	}
  25. }
  26. int GetMidIndex(int* a, int left, int right)
  27. {
  28. 	int mid = (left + right) / 2;
  29. 	if (a[left] < a[mid])
  30. 	{
  31. 		if (a[mid] < a[right])
  32. 			return mid;
  33. 		else if (a[left] < a[right])
  34. 			return right;
  35. 		else
  36. 			return left;
  37. 	}
  38. 	else //a[left] > a[mid]
  39. 	{
  40. 		if (a[mid] > a[right])
  41. 			return mid;
  42. 		else if (a[left] > a[right])
  43. 			return right;
  44. 		else
  45. 			return left;
  46. 	}
  47. }
  48. // 快速排序前后指针法
  49. //[left, right]
  50. int PartSort3(int* a, int left, int right)
  51. {
  52. 	int midi = GetMidIndex(a, left, right);
  53. 	Swap(&a[left], &a[midi]);
  54.  
  55. 	int prev = left;
  56. 	int cur = left + 1;
  57. 	int keyi = left;
  58. 	while (cur <= right)
  59. 	{
  60. 		if (a[cur] < a[keyi] && ++prev != cur)
  61. 		{
  62. 			Swap(&a[prev], &a[cur]);
  63. 		}
  64. 		cur++;
  65. 	}
  66. 	Swap(&a[prev], &a[keyi]);
  67. 	keyi = prev;
  68. 	return keyi;
  69. }
  70. void QuickSort(int* a, int left, int right)
  71. {
  72. 	//子区间只有一个值，或者子区间不存在的时候递归结束
  73. 	if (left >= right)
  74. 		return;
  75.  
  76. 	//小区间优化
  77. 	if (right - left + 1 < 10)
  78. 	{
  79. 		InsertSort(a + left, right - left + 1);
  80. 	}
  81.  
  82. 	int keyi = PartSort3(a, left, right);
  83. 	QuickSort(a, left, keyi - 1);
  84. 	QuickSort(a, keyi + 1, right);
  85. }
 

这两种优化的方式在时间与空间两个方面都有一定程度的提升，但快速排序的本质没有改变，优化只是在原有的思想上锦上添花。

                

        
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/498991
推荐阅读
相关标签
Copyright ©  2003-2013 www.wpsshop.cn  版权所有，并保留所有权利。

  
闽ICP备14008679号