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

        快速排序的原理是交换排序，其中qsort函数用的排序原理就是快速排序，它是一种效率较高的不稳定函数，时间复杂度为O(N*longN)，接下来就来学习一下快速排序。

一、快速排序思路

1.整体思路

以升序排序为例：

        (1)、首先随便找一个数(一般取首元素)作为排序对象(记为key)，先将这个数排到准确的位置，即把小于等于key的全部放在key左边，大于key的全部放在key右边。这是排一趟需要做的事。

        (2)、排完一趟后被排的那个数key此时它在的位置是准确的，接下来只需要用同样的方法分别对它的左数组和右数组排序，这就有点类似于二叉树的前序遍历。

如下：

  1. void QuickSort(int* arr, int left, int right)
  2. {
  3. 	if (left >= right)//如果左区间>=右区间就不用再排，直接返回。
  4. 		return;
  5. 	int key=_Sort3(arr, left, right);//该函数用来排单趟
  6. 	QuickSort(arr, left, key - 1);
  7. 	QuickSort(arr, key + 1, right);
  8. }

        至于排单趟的算法一般有三种分别是：霍尔法，挖坑法，前后指针法。在下面会细讲。 

2.单趟排序

2.1.霍尔法

        把第一个元素当排序对象key(首元素的下标)，用L储存左下标，R储存右下标。先让R从右往左走找到比key小的元素时停下，然后让L从左往右走找到比key大的元素停下。然后把位于L位置和位于R位置的的值进行交换，最后重复上面的操作直到L>=R为止。再把key的位置与L位置的值交换。至此一趟排序就结束了。

代码示例：

  1. int _Sort1(int* arr, int begin, int end)//霍尔法
  2. {
  3. 	int key = begin;
  4. 	while (begin < end)
  5. 	{
  6. 		while (begin < end && arr[end] > arr[key])
  7. 			end--;
  8. 		while (begin < end && arr[begin] <= arr[key])
  9. 			begin++;
  10. 		Swap(&arr[begin], &arr[end]);
  11. 	}
  12. 	Swap(&arr[key], &arr[begin]);
  13. 	key = begin;
  14. 	return key;
  15. }

2.1.挖坑法

          把首元素当做排序对象赋值给key，然后把第一个下标L当做坑位，让R从右边出发找到比key小的数放在坑位，然后R的位置变成坑位，让L从左往右找到比key大的数放在坑位，L位置变成坑位，再次让R走，循环往复直到L与R相遇。最后把key放在坑位，至此一趟排序结束。

 代码示例：

  1. int _Sort2(int* arr, int begin, int end)
  2. {
  3. 	int key = arr[begin];
  4. 	int kw = begin;//坑位下标
  5. 	while (begin < end)
  6. 	{
  7. 		while (begin < end && arr[begin] < key)
  8. 			begin++;
  9. 		arr[kw] = arr[begin];
  10. 		kw = begin;
  11. 		while (begin < end && arr[end] >= key)
  12. 			end--;
  13. 		arr[kw] = arr[end];
  14. 		kw = end;
  15. 	}
  16. 	arr[kw] = key;
  17. 	return kw;
  18. }

2.3.前后指针法

         把第一个元素当排序对象key(首元素的下标)，prev指向首元素下标，cur指向首元素下一个元素下标。

        如果cur指向的元素小于key的话prev向右走，并且如果prev不等于cur，那么把prev与cur互换。最后cur都需要无条件向右走一步。

代码示例：

  1. int _Sort3(int* arr, int begin, int end)//前后指针法
  2. {
  3. 	int perv = begin, cur = begin + 1;
  4. 	while (cur <= end)
  5. 	{
  6. 		if (arr[cur] < arr[begin] && ++perv != cur)
  7. 			Swap(&arr[perv], &arr[cur]);
  8. 		cur++;
  9. 	}
  10. 	Swap(&arr[perv], &arr[begin]);
  11. 	return perv;
  12. }

二、提供效率的方法

1.三数取中(key值的选取)

        快速排序的"三数取中"（Median of Three）是一种优化技术，它相当于选排序对象key。其具体做法如下：

        (1).选择三个元素：从待排序数组中选择三个关键元素，通常是第一个元素、中间元素和最后一个元素。
        (2).比较并选择中位数：将这三个元素进行比较，选择值不是最大也不是最小的数。比如，如果三个元素分别是arr[left]、arr[mid]、arr[right]，则中位数是介于这三个值之间的那个数。
        (3).交换为第一个元素：将选定的中位数元素与数组的第一个元素交换位置，以便在后续的快速排序中使用。

        通过使用"三数取中"的方法，可以有效地减少快速排序中最坏情况的发生概率，因为选取的主元更有可能接近数组的中值，而不是极端值。这样可以更均匀地划分数组，减少排序的平均时间复杂度，提高算法的整体性能。

2.小区间优化

        小区间优化指的是在快速排序算法中针对较小规模的子数组（或子问题）采用其他排序方法，而不是继续使用快速排序本身。这种优化技术的目的是避免在小规模问题上快速排序的递归调用带来的额外开销，提高算法的整体效率。
        具体来说，当快速排序的递归过程划分的子数组规模减小到一定程度时，可以选择使用插入排序或其他适合小规模数组的排序方法来处理。这样可以避免递归深度过深，减少递归调用和分区操作的开销，从而提高整体排序算法的性能。
具体的优化策略包括：

        (1).设定阈值：在实现快速排序时设定一个阈值，当子数组的大小小于这个阈值时，转而使用插入排序或者直接选择排序等方法进行排序。常见的阈值一般设定在5到10之间，具体取决于具体实现和排序数据的特性。
        (2).切换到其他排序算法：在快速排序的递归过程中，当子数组大小小于设定的阈值时，停止快速排序的递归，转而使用其他排序算法完成剩余的排序工作。

        小区间优化技术能有效降低快速排序在小规模数据上的不必要开销，提高整体排序算法的效率和性能。

三、非递归实现

        把递归该为非递归毋庸置疑首先考虑使用栈结构，这里我们需要抓住重点，考虑需要用栈结构储存什么数据，先从函数参数上看左右区间的参数是一直在变化的，那么只需要把区间储存到栈中，每次从栈中就可以取到需要排序的区间，对这个区间进行一趟排序后再分为两个小区间存入栈中，重复以上操作直到栈为空。

四、源码

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include
  3. #include
  4. #include
  5. #include"Stack.h"
  6. #define size 100
  7. void Swap(int* a, int* b)
  8. {
  9. 	int c = *a;
  10. 	*a = *b;
  11. 	*b = c;
  12. }
  13. void InsertSort(int* arr, int sz)//插入排序(小区间优化)
  14. {
  15. 	for (int i = 0; i < sz - 1; i++)
  16. 	{
  17. 		int j = i;
  18. 		int tmp = arr[j + 1];
  19. 		while (j >= 0 && tmp < arr[j])
  20. 		{
  21. 			arr[j + 1] = arr[j--];
  22. 		}
  23. 		arr[j + 1] = tmp;
  24. 	}
  25. }
  26. int Sk(int* arr, int left, int right)//三数取中
  27. {
  28. 	int v = (left + right) / 2;
  29. 	if (arr[left] > arr[right])
  30. 	{
  31. 		if (arr[right] > arr[v])
  32. 			return right;
  33. 		else
  34. 		{
  35. 			if (arr[left] < arr[v])
  36. 				return left;
  37. 			else
  38. 				return v;
  39. 		}
  40. 	}
  41. 	else
  42. 	{
  43. 		if (arr[left] > arr[v])
  44. 			return left;
  45. 		else
  46. 		{
  47. 			if (arr[right] > arr[v])
  48. 				return right;
  49. 			else
  50. 				return v;
  51. 		}
  52. 	}
  53. }
  54. int _Sort1(int* arr, int begin, int end)//霍尔法
  55. {
  56. 	int key = begin;
  57. 	while (begin < end)
  58. 	{
  59. 		while (begin < end && arr[end] > arr[key])
  60. 			end--;
  61. 		while (begin < end && arr[begin] <= arr[key])
  62. 			begin++;
  63. 		Swap(&arr[begin], &arr[end]);
  64. 	}
  65. 	Swap(&arr[key], &arr[begin]);
  66. 	key = begin;
  67. 	return key;
  68. }
  69. int _Sort2(int* arr, int begin, int end)//挖坑法
  70. {
  71. 	int val = arr[begin];
  72. 	int kw = begin;//坑位
  73. 	while (begin < end)
  74. 	{
  75. 		while (begin < end && arr[begin] < val)
  76. 			begin++;
  77. 		arr[kw] = arr[begin];
  78. 		kw = begin;
  79. 		while (begin < end && arr[end] >= val)
  80. 			end--;
  81. 		arr[kw] = arr[end];
  82. 		kw = end;
  83. 	}
  84. 	arr[kw] = val;
  85. 	return kw;
  86. }
  87. int _Sort3(int* arr, int begin, int end)//前后指针法
  88. {
  89. 	int perv = begin, cur = begin + 1;
  90. 	while (cur <= end)
  91. 	{
  92. 		if (arr[cur] < arr[begin] && ++perv != cur)
  93. 			Swap(&arr[perv], &arr[cur]);
  94. 		cur++;
  95. 	}
  96. 	Swap(&arr[perv], &arr[begin]);
  97. 	return perv;
  98. }
  99. void QuickSort(int* arr, int left, int right)//快速排序(递归实现)
  100. {
  101. 	if (left >= right)
  102. 		return;
  103. 	if (right - left <= 10)
  104. 	{
  105. 		InsertSort(arr + left, right - left + 1);
  106. 		return;
  107. 	}
  108. 	int key=_Sort1(arr, left, right);
  109. 	QuickSort(arr, left, key - 1);
  110. 	QuickSort(arr, key + 1, right);
  111. }
  112. void QuickSortNoR(int* arr, int left, int right)//快速排序(非递归)
  113. {
  114. 	Stack st;
  115. 	StackInit(&st);//关于栈结构的函数实现在这里并未展示，已在Stack.h中声明
  116. 	StackPush(&st, right);
  117. 	StackPush(&st, left);
  118. 	while (!StackEmpty(&st))
  119. 	{
  120. 		int begin = StackTop(&st);
  121. 		StackPop(&st);
  122. 		int perv = begin, cur = begin + 1;
  123. 		int end = StackTop(&st);
  124. 		StackPop(&st);
  125. 		if (begin >= end)
  126. 			continue;
  127. 		while (cur <= end)
  128. 		{
  129. 			if (arr[cur] < arr[begin] && ++perv != cur)
  130. 				Swap(&arr[cur], &arr[perv]);
  131. 			cur++;
  132. 		}
  133. 		Swap(&arr[begin], &arr[perv]);
  134. 		StackPush(&st, end), StackPush(&st, perv + 1);
  135. 		StackPush(&st, perv - 1), StackPush(&st, begin);
  136. 	}
  137. 	StackDestroy(&st);
  138. }
  139. int main()
  140. {
  141. 	int arr[size] = { 0 };
  142. 	srand((unsigned int)time(NULL));//随机数种子
  143. 	for (int i = 0; i < size; i++)
  144. 	{
  145. 		arr[i] = rand() % 1000 + 1;//生成随机数赋值给arr[i]
  146. 	}
  147. 	QuickSort(arr, 0, size - 1);
  148. 	for (int i = 0; i < size; i++)
  149. 	{
  150. 		printf("%-3d ", arr[i]);
  151. 		if ((i + 1) % 20 == 0)
  152. 			printf("\n");
  153. 	}
  154. 	return 0;
  155. }

文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览62102 人正在系统学习中
注：本文转载自blog.csdn.net的敲上瘾的文章"https://blog.csdn.net/2302_80105876/article/details/140054757"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！