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

【排序算法】快速排序（全坤式超详解）———有这一篇就够啦

作者：weixin_40725706 | 2024-05-26 13:49:04

赞

踩

【排序算法】快速排序（全坤式超详解）———有这一篇就够啦

【排序算法】——快速排序

目录

一：快速排序——思想

二：快速排序——分析

三：快速排序——动态演示图

四：快速排序——单趟排序

4.1：霍尔法

4.2：挖坑法

4.3：前后指针法

五：快速排序——递归实现

5.1：快速排序--->常规法

5.2：快速排序--->三路划分法

六：快速排序——非递归实现

七：快速排序——优化

7.1：快速排序优化--->三数取中选key法

7.2：快速排序优化--->随机数生成选key法

7.3：快速排序优化--->小区间改造

八：快速排序——特性总结

一：快速排序——思想与大致框架

        快速排序是Hoare（霍尔）于1962年提出的一种二叉树结构的交换排序方法。

其基本思想为：

  1. 任取待排序元素序列中的某元素作为基准值，
  2. 按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，
  3. 然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

 由快排思想可以推出快速排序的大致框架如下：

  1. #include <stdio.h>
  2.  
  3.     // 假设按照升序对array数组中[begin, end]区间中的元素进行排序
  4.  
  5. void QuickSort(int array[], int begin, int end) 
  6. {
  7.     if (begin >= end)
  8. 	{
  9. 		return;
  10. 	}
  11.  
  12.      // 按照基准值对array数组的 [begin, end]区间中的元素进行划分
  13.  int keyi = PartSort(array, begin, end);
  14.  
  15.      // 划分成功后以keyi为边界形成了左右两部分 [begin, keyi-1] keyi [div+1, end]
  16.      // 左部分都是比 keyi 位置上的值小的部分，右部分都是比 keyi 位置上的值大的部分。
  17.      // 递归排左部分[begin, keyi-1]
  18.  QuickSort(array, begin, keyi);
  19.  
  20.      // 递归排右部分[keyi+1, end]
  21.  QuickSort(array, keyi+1, end);
  22.  
  23. }
  24.  
  25. int main()
  26. {
  27. 	int a[] = { 2,5,7,1,4,9,6,3,8,0 };
  28.  
  29. 	int sz = sizeof(a) / sizeof(a[0]);    // 求取数组内元素个数
  30.  
  31. 	QuickSort(a, 0,sz-1);                // 传递的都是下标
  32.  
  33.     return 0;
  34. }

        我们发现与二叉树前序遍历规则非常像，所以我们在分析快速排序过程中的递归框架时可想想二叉树前序遍历规则即可理解并快速写出来，在后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。 

二：快速排序——分析

        对于快速排序，重点就在于基准值 key 的位置，知道 key 的位置之后，分别再对左右两边部分再找 基准值 key 的位置，依次在各个部分区间内找 基准值 key，通过一遍又一遍的递归，到最后区间内只有一个数时，这个递归也就结束了。具体情况，大家可以通过快速排序的动态演示图和递归分解图进行分析。

三：快速排序——动态演示图

快速排序递归演示图：

我们发现它大致就是一个二叉树的前序遍历形态。大家可以一边看图一边进行分析。 

四：***快速排序——单趟排序****

将区间按照基准值划分为左右两半部分的常见方式有：1.霍尔法；2.挖坑法；3.前后指针法

4.1：霍尔法

        因为霍尔是最早实现快速排序的人，所以霍尔法也是整个快排最早的版本。

单趟排序的目的：将区间按照基准值划分为左右两半部分，左边部分比基准值小，右边部分比基准值大。

 霍尔法单趟过程分析：

  1. 先记录下基准值key的位置，让 left 和 right 向两端靠近（直至相遇）。
  2. right 小兵先走，直到遇到一个比 key 值要小的数字就停下。
  3. right 小兵停下后，left 小兵再走，直到遇到一个比 key 值要大的数字就停下。
  4. 交换 left 位置和 right 位置上的值。
  5. right 小兵继续走，重复 2，3，4动作，直到 left 小兵与 right 小兵相遇
  6. 相遇之后，将相遇位置的值与基准值 key 位置上的值交换，让相遇位置置成新的 key。

注意：基准值 key 在左边， right 小兵先走；基准值 key 在右边，left 小兵先走。

那么，相信大家会有这样的疑问，如果相遇位置的值比基准值 key 位置上的值大怎么办？无需担心，相遇位置的值一定就是比基准值 key 位置上的值小。

这需要两个方面进行分析：一方面是 key 在左边，另一方面就是 key 在右边。

key 位置在左边

就相遇位置值分析：

若 left 小兵与 right 小兵相遇，又有两种情况：1. left 小兵走的时候，遇到 right 小兵（L遇）；2.right 小兵走的时候，遇到 left 小兵（R遇L）。

1. left 小兵走的时候，遇到 right 小兵

 因为是 key 位置在左边， right 小兵先走，所以当 right 小兵停下时，其位置上的值一定是比 key 位置上的值小的。这时，left 小兵来了， 两个小兵相遇，相遇的位置就是 right 小兵停下的位置，即相遇的位置比 key 位置上的值要小。

2. right 小兵走的时候，遇到 left 小兵

因为是 key 位置在左边， right 小兵先走。经过几轮交换之后，相遇的位置就是 left 小兵的位置，此时，因为经过了上一轮 left 位置上的值 与 right 位置上的值 交换。left 位置上的值就是上一轮交换中 right 停下位置上那个比 key 值小的值。即交换之后 left 位置上的值是比 key 位置上的值要小的，所以相遇的位置比 key 位置上的值要小。

同理，key 位置在右边的时候，也是相同的情况分析。

下面我们来看一看 hoare 版本的代码，一起来分析一下。

  1. // 单趟排序
  2. //		1.霍尔法
  3. int PartSort1(int* a, int left, int right)
  4. {
  5. 	int keyi = left;                // 记录下 key 的位置
  6. 	while (left < right)            // 当 left 与 right 相遇时退出循环
  7. 	{
  8. 		// 右边找小
  9. 		while (left < right && a[right] >= a[keyi])
  10. 		{
  11. 			--right;
  12. 		}
  13. 		// 左边找大
  14. 		while (left < right && a[left] <= a[keyi])
  15. 		{
  16. 			++left;
  17. 		}
  18.         // 此时 right 位置上的值要比 keyi 位置上的值小，left 位置上的值要比 keyi 位置上的值大
  19.         // 交换 left 位置与 right 位置上的值。
  20. 		Swap(&a[left], &a[right]);      // 交换后 left 位置上的值比 keyi位置上的值小， right 位置上的值比 keyi 位置上的值大。
  21. 	}
  22.  
  23.     // left 与 right 相遇
  24. 	Swap(&a[left], &a[keyi]);
  25. 	keyi = left;            // 生成新的 keyi 位置
  26. 	return keyi;
  27. }
  28.  
  29. // 霍尔单趟排序之后， keyi 位置左边的部分都比 keyi位置的值要小，keyi 位置右边的部分都比 keyi位置的值要大。

4.2：挖坑法

挖坑法的思路与霍尔法的思路大致相同。

挖坑法思路过程分析：

  1. 先将 key 的值存起来，注意：此处的 key 存的是值，而不是位置下标。将该数据位置看作是一个坑（记作是 hole ）。
  2. 最初时，left 小兵在最左边（下标为0的位置），right 小兵在最右边。
  3. 如下动图中，因为 hole坑在最左边，所以还是 right 小兵先走，找比 key值要小的值。找到之后，将 right 位置上的值放到原来的坑上，在将此时 right 位置 记作新坑。
  4. right 位置上形成一个新坑后，left 小兵出发，找比 key 值要大的值。找到之后，将 left 位置上的值放到原来的坑上，在将此时 left 位置 记作新坑。
  5. left 位置上形成新坑后，right 小兵再走，重复3，4动作，直到 left 小兵与 right 小兵相遇。
  6. 相遇之后，将坑上填入 key 值。
  7. 最后返回 hole 最后的位置，这个位置就是基准值。

可以确定：两个小兵相遇的位置一定是一个坑。

注意：有坑的小兵不走；填坑时，要先将原来的坑给补上，再建立新坑。

 单趟排序挖坑法代码实现：

  1. // 2.挖坑法
  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. 		while (left < right && a[left] <= key)
  17. 		{
  18. 			++left;
  19. 		}
  20. 		a[hole] = a[left];
  21. 		hole = left;
  22. 	}
  23. 	a[hole] = key;        // 最后一个坑填 基准值 key
  24. 	return hole;          // 返回基准值的下标
  25. }

4.3：前后指针法

这三种单趟排序的方法思想都是差不多的。不过这种方法不仅是思路还是实现效率都比其他两中方法要好一些，同时这种方法也是大众比较流行的方法之一。

前后指针法思路过程分析：

  1. 先记录下基准值key的位置，不过这种方法不是 right 小兵和 left 小兵往中间走了，而是先用一个 “指针prev” 记录left 的位置，再用一个 “指针cur” 记录 left+1 的位置。
  2. 此时 cur 小兵要找比 key 位置上的值要小的，找到之后，并且 prev+1 != cur，就让 prev+1 的位置上的值与 cur 位置上的值进行交换。
  3. 交换后 cur++，prev++。
  4. 依次重复2，3直至结束循环（cur > right）
  5. 最后将 prev 位置上的值与 key 位置上的值进行交换。再 key = prev。
  6. 返回 key 位置的下标

  单趟排序前后指针法代码实现：

  1. // 3.前后指针法
  2. int PartSort3(int* a, int left, int right)
  3. {
  4. 	int prev = left;            // 定义一个 prev “指针”
  5. 	int cur = left + 1;         // 定义一个 cur “指针”
  6. 	int keyi = left;            // 先确定基准值的位置
  7.  
  8. 	while (cur <= right)
  9. 	{
  10. 		while (a[cur] <= a[keyi] && ++prev != cur)    // cur指针找小，并且 prev先+1，加1之后再进行交换（简化代码）
  11. 		{
  12. 			Swap(&a[cur], &a[prev]);
  13. 		}
  14.  
  15. 		++cur;
  16. 	}
  17. 	Swap(&a[prev], &a[keyi]);        // 交换 key 位置上的值与 prev 位置上的值
  18. 	keyi = prev;
  19. 	return keyi;
  20. }

五：快速排序——递归实现

5.1：快速排序--->常规法

所谓常规法，就是按照我们前面的思路对快速排序进行总结实现，无任何添加，即是常规。

  1. #include<stdio.h>
  2.  
  3. // 快排单趟排序
  4. //        前后指针法
  5. int PartSort(int* a, int left, int right)
  6. {
  7. 	int prev = left;
  8. 	int cur = left + 1;
  9. 	int keyi = left;
  10.  
  11. 	while (cur <= right)
  12. 	{
  13. 		while (a[cur] <= a[keyi] && ++prev != cur)
  14. 		{
  15. 			Swap(&a[cur], &a[prev]);
  16. 		}
  17.  
  18. 		++cur;
  19. 	}
  20. 	Swap(&a[prev], &a[keyi]);
  21. 	keyi = prev;
  22. 	return keyi;
  23. }
  24.  
  25.  
  26. // 快排递归实现
  27. void QuickSort(int* a, int begin, int end)
  28. {
  29. 	if (begin >= end)
  30. 	{
  31. 		return;
  32. 	}
  33.  
  34. 	int keyi = PartSort(a, begin, end);
  35. 	// [beign,keyi-1] keyi [keyi+1,end]
  36.  
  37. 	QuickSort(a, begin, keyi - 1);
  38. 	QuickSort(a, keyi + 1, end);
  39. }
  40.  
  41.  
  42. // 快速排序
  43. int main()
  44. {
  45. 	int a[] = { 2,5,7,1,4,9,6,3,8,0 };
  46.  
  47. 	int sz = sizeof(a) / sizeof(a[0]);
  48.  
  49. 	QuickSort(a, 0,sz-1);
  50.  
  51.     return 0;
  52. }

5.2：快速排序--->三路划分法

万事总有漏洞，但总会有大佬来填补这些漏洞。

当一个数组序列中含有多个相同元素的时候，单纯的使用常规法已经不能发挥出独属于快排的全部威力了。这就有大佬提出了三路划分法来解决这一问题。

图：

以下个数组序列为例：

此处：L 指的是 left，c 指的是 cur，R 指的是 right。 

 三路划分法的思想：

  1. 当 a[cur] < key，交换 cur 和 left 位置上的值，left++，cur++。
  2. 当 a[cur] > key，交换 cur 和 right 位置上的值，right--。
  3. 当 a[cur] == key，cur++。

三路划分法的本质：

  • 小的甩到左边，大的甩到右边。、
  • 与 key 值相等的值推到中间。

三路划分法的结果：

[ begin , left-1 ] [ left , right ] [ right + 1 , end ]

三路划分法代码实现：

  1. #include<stdio.h>
  2.  
  3. // 快速排序--递归法---三路划分法
  4. void QuickSort1(int* a, int begin, int end)
  5. {
  6. 	if (begin >= end)
  7. 	{
  8. 		return;
  9. 	}
  10.  
  11. 	int left = begin;
  12. 	int right = end;
  13. 	int key = a[left];
  14. 	int cur = left + 1;
  15.  
  16. 	while (cur <= right)
  17. 	{
  18. 		if (a[cur] > key)
  19. 		{
  20. 			Swap(&a[cur], &a[right]);
  21. 			--right;
  22. 		}
  23. 		else if (a[cur] < key)
  24. 		{
  25. 			Swap(&a[left], &a[cur]);
  26. 			++left;
  27. 			++cur;
  28. 		}
  29. 		else
  30. 		{
  31. 			++cur;
  32. 		}
  33. 	}
  34.  
  35. 	// [begin,left-1][left,right][righ+1,end]
  36.  
  37. 	QuickSort1(a, begin, left - 1);
  38. 	QuickSort1(a, right + 1, end);
  39. }
  40.  
  41. // 快速排序
  42. int main()
  43. {
  44. 	int a[] = { 6,1,6,7,9,6,4,5,6,8 };
  45.  
  46. 	int sz = sizeof(a) / sizeof(a[0]);
  47.  
  48. 	QuickSort(a, 0,sz-1);
  49.  
  50.     return 0;
  51. }

六：快速排序——非递归实现

        因为递归这个过程是在内存中的栈空间内实现的，但是在内存中栈所含有的空间很少，当递归层数太多时，往往存在栈溢出的情况，那么解决的方法，就是将递归版本改为非递归版本，这就需要借助以前学的栈（先进后出）这一工具来模拟实现非递归的快速排序，因为栈是在内存中的堆区实现的，而内存上的堆空间很大很大，完全不需要考虑空间溢出的问题。

实现非递归的思路：

  1. 入栈一定要保证先入右，再入左。
  2. 取两次栈顶元素作为 区间的 left 和 right。
  3. 对该区间进行单趟排序。排序完：[ left , keyi - 1 ] keyi [ keyi + 1 , right ]
  4. 重复2，3过程直到栈为空。

快速排序非递归代码实现：

  1. // 快速排序--非递归法
  2. void QuickSortNonR(int* a, int begin, int end)
  3. {
  4. 	Stack st;            // 定义一个栈
  5. 	STInit(&st);
  6.  
  7. 	STPush(&st, end);    // 栈：先入右
  8. 	STPush(&st, begin);  // 再入左
  9.  
  10. 	while (!STEmpty(&st))
  11. 	{
  12. 		int left = STTop(&st);    // 取栈顶作为 区间的左边界
  13. 		STPop(&st);
  14.  
  15. 		int right = STTop(&st);   // 取栈顶作为 区间的右边界
  16. 		STPop(&st);
  17.  
  18. 		int keyi = PartSort2(a, left, right);    // 单趟排序得出 keyi
  19. 		// [left,keyi-1]keyi[keyi+1,right]
  20.  
  21. 		if (left < keyi - 1)                // 判断该区间是否合法
  22. 		{
  23. 			STPush(&st, keyi - 1);
  24. 			STPush(&st, left);
  25. 		}
  26. 		if (keyi + 1 < right)               // 判断该区间是否合法
  27. 		{
  28. 			STPush(&st, right);
  29. 			STPush(&st, keyi + 1);
  30. 		}
  31. 	}
  32.  
  33. 	STDestroy(&st);
  34. }

效果演示：

七：快速排序——优化

7.1：快速排序优化--->三数取中选key法

        在快速排序问世以来，一些人发现，keyi 的位置，是影响快排效率的最大因素，将 keyi 放在合理的位置就可再次增大该排序的运行效率。因此就有一些大佬采用了三数取中的方法解决选 keyi 位置不合适的问题。

所谓三数取中：就是取头，中，尾三个元素，比较大小，选择那个排在中间的数据作为基准值 keyi 。再进行快速排序，这种优化方法就能使该排序效率比原来高。

 三数取中优化法代码实现：

  1. // 快速排序--优化1---三数取中选key
  2. int GetMidIndex1(int* a, int left, int right)
  3. {
  4. 	int mid = (left + right) / 2;
  5. 	if (a[left] < a[mid])
  6. 	{
  7. 		if (a[mid] < a[right])
  8. 		{
  9. 			return mid;
  10. 		}
  11. 		else if (a[right] < a[left])
  12. 		{
  13. 			return left;
  14. 		}
  15. 		else
  16. 		{
  17. 			return right;
  18. 		}
  19. 	}
  20. 	else
  21. 	{
  22. 		if (a[mid] > a[right])
  23. 		{
  24. 			return mid;
  25. 		}
  26. 		else if (a[right] > a[left])
  27. 		{
  28. 			return left;
  29. 		}
  30. 		else
  31. 		{
  32. 			return right;
  33. 		}
  34. 	}
  35. }

这样一来，中间值的下标就被返回过来了，将其带入到快排代码中，让它成为新的 keyi 。

  1. // 快速排序--递归法
  2. void QuickSort(int* a, int begin, int end)
  3. {
  4. 	if (begin >= end)
  5. 	{
  6. 		return;
  7. 	}
  8.  
  9. 	int mid = GetMidIndex1(a, begin, end);
  10. 	Swap(&a[begin], &a[mid]);        // 再交换中间值位置与最左边位置
  11.  
  12. 	int keyi = PartSort3(a, begin, end);
  13. 	// [beign,keyi-1] keyi [keyi+1,end]
  14.  
  15. 	QuickSort(a, begin, keyi - 1);
  16. 	QuickSort(a, keyi + 1, end);
  17. }

7.2：快速排序优化--->随机数生成选key法

有人说，三数取中法有些死板，所取的值只能是固定位置，于是又有人在基于三数取中优化法之上，进行了再次优化——随机数生成选 key 法。

随机数生成选 key 法：就是 mid 的值并不只能是 (left+right) / 2 得来的，而是由 随机数生成而来。即  mid = left + (rand() % (right - left))。

随机数生成选 key 法代码实现：

  1. // 快速排序--优化2---随机数选key
  2. int GetMidIndex2(int* a, int left, int right)
  3. {
  4. 	int mid = left + (rand() % (right - left));
  5. 	if (a[left] < a[mid])
  6. 	{
  7. 		if (a[mid] < a[right])
  8. 		{
  9. 			return mid;
  10. 		}
  11. 		else if (a[right] < a[left])
  12. 		{
  13. 			return left;
  14. 		}
  15. 		else
  16. 		{
  17. 			return right;
  18. 		}
  19. 	}
  20. 	else
  21. 	{
  22. 		if (a[mid] > a[right])
  23. 		{
  24. 			return mid;
  25. 		}
  26. 		else if (a[right] > a[left])
  27. 		{
  28. 			return left;
  29. 		}
  30. 		else
  31. 		{
  32. 			return right;
  33. 		}
  34. 	}
  35. }

7.3：快速排序优化--->小区间改造

        因为快速排序是递归实现进行的，所以当递归到最后几层时，数组中的值其实已经接近有序了，并且这时再次进行递归会极大占用栈(函数栈帧开辟的地方，函数的递归都是在栈中进行实现的)的空间。

由于我们的快排递归类似于二叉树这样的结构，即越到最后所递归的次数越多。所以我们对其进行优化，当其区间内个数小于等于 10 时，就使用插入排序算法对其进行排序

那么该如何将其带入到快速排序的代码中来呢？

小区间改造法代码实现：

  1. // 插入排序
  2. void InsertSort(int* a, int n)
  3. {
  4. 	for (int i = 1; i < n; i++)
  5. 	{
  6. 		int tmp = a[i];
  7. 		int end = i - 1;
  8. 		while (end >= 0)
  9. 		{
  10. 			if (a[end] > tmp)
  11. 			{
  12. 				a[end + 1] = a[end];
  13. 				--end;
  14. 			}
  15. 			else
  16. 			{
  17. 				break;
  18. 			}
  19. 		}
  20. 		a[end + 1] = tmp;
  21. 	}
  22. }
  23.  
  24. // 快速排序--递归法
  25. void QuickSort(int* a, int begin, int end)
  26. {
  27. 	if (begin >= end)
  28. 	{
  29. 		return;
  30. 	}
  31.  
  32. 	if (end - begin <= 10)
  33. 	{
  34. 		InsertSort(a, end - begin + 1);    // [begin,end] 两个闭区间，求个数要 +1
  35. 		return;
  36. 	}
  37.  
  38. 	int mid = GetMidIndex2(a, begin, end);
  39. 	Swap(&a[begin], &a[mid]);
  40.  
  41. 	int keyi = PartSort3(a, begin, end);
  42. 	// [beign,keyi-1] keyi [keyi+1,end]
  43.  
  44. 	QuickSort(a, begin, keyi - 1);
  45. 	QuickSort(a, keyi + 1, end);
  46. }

八：快速排序——特性总结

1. 时间复杂度：O(N*logN)
2. 空间复杂度：O(logN)
3. 稳定性：不稳定

 快速排序思导图：

总结：本篇介绍了关于快速排序的hoare法，挖坑法，前后指针法单趟排序，以及三种快速排序的实现和三种优化。总的来说，还是有一些难度的，建议大家多多看看动图和思维导图用于辅助大家理解快排，多多动手，总之，这篇内容是相当硬核的，难度也有些大，当然希望这篇内容对大家理解快速排序能够有用。

这篇文章到这里就结束了，希望大家多多支持，可以的话用小手点个小虹心或者关注一下呀。大家的反馈是我更新最大动力。

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

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号