• 排序算法：快速排序（三种排序方式、递归和非递归）

    朋友们、伙计们，我们又见面了，本期来给大家解读一下有关排序算法的相关知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

    C 语 言 专 栏：C语言：从入门到精通

    数据结构专栏：数据结构

    个  人  主  页 ：stackY、

    目录

    前言：

    1.快速排序

    1.1递归版本

    1.1.1hoare版本

    代码演示：

    1.1.2挖坑法

     代码演示：

    1.1.3前后指针（下标）版本

     代码演示：

    1.1.4时间复杂度 

    1.1.5快速排序的优化

    优化完整代码： 

     1.2非递归版本

    代码演示： 

    前言：

    在前面的文章我们分别介绍了插入排序和选择排序，那么在本期的学习中我们来了解一下快速排序，以及快速排序的三种实现方式以及递归和非递归的实现，话不多说，正文开始：

    快速排序和冒泡排序是属于交换排序这个范畴内的，冒泡排序在前面的文章中非常细致的讲解过，那么在这里就不做赘述，直接开始快速排序即可：

    1.快速排序

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

    1.1递归版本

    首先我们使用递归的方式来实现快速排序，后面再使用非递归来完成，因为递归太深是会有风险的。在递归版本的快速排序下对于排序区间的划分有三种方法：1.hoare版本、2.挖坑法、3.前后指针法。那么我们来一一学习。

    1.1.1hoare版本

    我们要对一段数据进行排升序的处理：首先我们取一个关键值key（基准值），那么我们一般取的是最左边或者最右边的数据，然后设置两个下标：左下标和右下标，左下标，进行一趟排序：左下标从左向右开始找比key大的，右下标从右向左找比key小的，然后左右下标的值交换，然后再重复此过程，当左右下标重叠时，将key与重叠位置的数据进行交换。一趟排序之后得到的结果就是key左边的都比key小，右边的都比key大，但是并不一定是有序，然后使用左右下标重合的位置将数据分为两个区间，然后再重复上述步骤，将这两个区间变为有序，那么左右区间都有序，数据的整体就有序了。

    那么在这就存在几个问题：

    1.怎么保证重叠位置的值就一定比key小呢？

    2.怎么让左右区间变为有序？

     1.怎么保证重叠位置的值就一定比key小呢？

    我们可以先让右下标开始走，然后让左下标开始走，因为右下标找的是比key小的值，先让右下标找到比key小的值，当左下标找到比key大的值时，两个值交换，当左下标找不到比key大的值时，这时左下标肯定和右下标重合，这时重合的就是右下标找到的比key小的，这时交换即可达到重叠时的数据比key小。

     2.怎么让左右区间变为有序？

    通过一次排序让数据变为两个区间，那么这两个区间再分别进行一次排序，再将它分为若干个小区间，这若干个小区间再进行排序，直到分出的区间只剩一个值或者分出的区间不存在，这时就达到了有序，那么就需要使用递归来进行左右区间的排序，递归截止的条件就是区间不存在或者区间里面只有一个数据。

    代码演示：
    1. void Swap(int* p1, int* p2)
    2. {
    3. 	int tmp = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = tmp;
    6. }
    7.  
    8. // 1. hoare版本
    9. int PartSort1(int* a, int left, int right)
    10. {
    11. 	//设置关键字
    12. 	int keyi = left;
    13.  
    14. 	while (left < right)
    15. 	{
    16. 		//右边先走
    17. 		//找比key小的
    18. 		while (left < right && a[keyi] <= a[right]) //先得判断下标是否合理
    19. 		{
    20. 			right--;
    21. 		}
    22. 		//找比key大的
    23. 		while (left < right && a[keyi] >= a[left])
    24. 		{
    25. 			left++;
    26. 		}
    27.  
    28. 		//交换
    29. 		Swap(&a[left], &a[right]);
    30. 	}
    31. 	//交换重叠位置的数据和key
    32. 	Swap(&a[keyi], &a[right]);
    33.  
    34. 	//将重叠位置返回
    35. 	return right;
    36. }
    37.  
    38.  
    39. void QuickSort(int* a, int begin, int end)
    40. {
    41. 	//递归截止条件
    42. 	if (begin >= end)
    43. 	{
    44. 		return;
    45. 	}
    46. 	
    47. 	//区间的划分
    48. 	int keyi = PartSort1(a, begin, end);
    49. 	//将整个数据划分为[begin, keyi-1] keyi [keyi+1, end]
    50. 	
    51. 	//递归右区间
    52. 	QuickSort(a, begin, keyi - 1);
    53. 	//递归左区间
    54. 	QuickSort(a, keyi + 1, end);
    55.  
    56. }
    57.  
    58. void PrintArry(int* a, int n)
    59. {
    60. 	for (int i = 0; i < n; i++)
    61. 	{
    62. 		printf("%d ", a[i]);
    63. 	}
    64. 	printf("\n");
    65. }
    66.  
    67. void TestQuickSort()
    68. {
    69. 	int a[] = { 3,2,5,10,6,8,9,7,1,4 };
    70. 	QuickSort(a, 0, sizeof(a) / sizeof(int) - 1);
    71. 	PrintArry(a, sizeof(a) / sizeof(int));
    72. }
    73.  
    74. int main()
    75. {
    76. 	TestQuickSort();
    77. 	return 0;
    78. }

     1.1.2挖坑法

    由于hoare版本的方法需要注意左右下标出发的先后顺序，那么就针对这一问题，有了一种新的方法：挖坑法

    同样的还是将最左边的数据作为关键数据，并且将它先保存，然后将这个位置设置为坑，然后设置左右两个下标，由于左边有坑，所以右下标先走，向前找比key小的值，找到了之后将这个值放在坑中，然后这个值的位置就形成了新的坑，然后左下标开始向后找比key大的，找到了之后将这个值放在新的坑中，此时又形成了一个坑，继续重复这个过程，当左右下标重叠时，再将刚开始保存的key放在这个坑中，即可完成一次排序，然后关键数据的这个位置又将数据分为两个区间，然后使用递归继续排序左右区间。

     代码演示：
    1. // 2. 挖坑法
    2. int PartSort2(int* a, int left, int right)
    3. {
    4. 	//保存关键值
    5. 	int key = a[left];
    6. 	//设置坑
    7. 	int hole = left;
    8.  
    9. 	//一次排序
    10. 	while (left < right)
    11. 	{
    12. 		//右边找小
    13. 		while (left < right && a[right] > key)
    14. 		{
    15. 			right--;
    16. 		}
    17. 		//找到了将其放入坑中，然后更新坑的位置
    18. 		a[hole] = a[right];
    19. 		hole = right;
    20. 		//左边找大
    21. 		while (left < right && a[left] < key)
    22. 		{
    23. 			left++;
    24. 		}
    25. 		a[hole] = a[left];
    26. 		hole = left;
    27. 	}
    28.  
    29. 	//最后把关键数据再放到坑中
    30. 	a[hole] = key;
    31. 	key = right;
    32. 	return key;
    33. }
    34.  
    35. void QuickSort(int* a, int begin, int end)
    36. {
    37. 	//递归截止条件
    38. 	if (begin >= end)
    39. 	{
    40. 		return;
    41. 	}
    42. 	
    43. 	//区间的划分
    44. 	int keyi = PartSort2(a, begin, end);
    45. 	//将整个数据划分为[begin, keyi-1] keyi [keyi+1, end]
    46. 	
    47. 	//递归右区间
    48. 	QuickSort(a, begin, keyi - 1);
    49. 	//递归左区间
    50. 	QuickSort(a, keyi + 1, end);
    51.  
    52. }

    1.1.3前后指针（下标）版本

    同样的还是取最左边作为关键数据，然后设置两个下标，一个指向起始位置（prev），一个指向起始位置的后一个位置（cur），然后比较cur指向的数据与key的大小，若cur小于key，则prev++，并且prev指向的数据和cur指向的数据进行交换（如果prev和cur指向的时同一个数据那么便不用交换），然后cur++，如果cur指向的数据大于key，则cur++，当cur越界时，将prev指向的数据和key交换，这时prev指向的位置就可以作为新的key将整个数据分为两个区间，这时就可使用递归继续来排序它的左右区间。

     代码演示：
    1. // 3.前后指针版本
    2. int PartSort3(int* a, int left, int right)
    3. {
    4. 	//设置关键数据
    5. 	int keyi = left;
    6. 	//前后指针（下标）
    7. 	int prev = left;
    8. 	int cur = left + 1;
    9. 	
    10. 	//判断cur的合法性
    11. 	while (cur <= right)
    12. 	{
    13. 		//如果cur指的数据小于关键数据且prev不等于cur即可完成交换
    14. 		if (a[cur] < a[keyi] && ++prev != cur)
    15. 		{
    16. 			Swap(&a[cur], &a[prev]);
    17. 		}
    18. 		cur++;
    19. 	}
    20. 	//cur越界之后再次交换prev与key
    21. 	Swap(&a[keyi], &a[prev]);
    22. 	keyi = prev;
    23. 	//返回新的关键位置
    24. 	return keyi;
    25. }
    26.  
    27. void QuickSort(int* a, int begin, int end)
    28. {
    29. 	//递归截止条件
    30. 	if (begin >= end)
    31. 	{
    32. 		return;
    33. 	}
    34. 	
    35. 	//区间的划分
    36. 	int keyi = PartSort3(a, begin, end);
    37. 	//将整个数据划分为[begin, keyi-1] keyi [keyi+1, end]
    38. 	
    39. 	//递归右区间
    40. 	QuickSort(a, begin, keyi - 1);
    41. 	//递归左区间
    42. 	QuickSort(a, keyi + 1, end);
    43.  
    44. }

    1.1.4时间复杂度 

    快速排序的递归版本与二叉树学习中的前序遍历逻辑相似，只需要注意区间的划分，那么根据二叉树的递归，一共需要递归\log N次，每一次进行遍历排序需要N次，那么快速排序的时间复杂度是：O(N* \log N) ，但是计算时间复杂度是按照最坏情况来考虑，当一组数据是有序的情况再来使用快速排序来排序这时它的时间复杂度就会变为O(N^2)，这时递归就需要N次，每一次的遍历也需要N次，所以就是N^2，因为我们每一次取到的关键数据都是左边的数据，那么就需要对如何取关键数据进行改进。

    1.1.5快速排序的优化

    为了优化快速排序最坏情况下的时间复杂度，那么我们需要对快速排序如何选择key做出改进：

    我们采用的是三数取中选key：

    选出最左边的数（left）、最右边的数（right）、中间数据（mid）这三个数据中大小顺序位于中间的数据作为key，然后与最左边的数进行交换，这样就达到了优化。

    优化完整代码： 
    1. void Swap(int* p1, int* p2)
    2. {
    3. 	int tmp = *p1;
    4. 	*p1 = *p2;
    5. 	*p2 = tmp;
    6. }
    7.  
    8. //三数取中选key
    9. int GetMidIndex(int* a, int left, int right)
    10. {
    11. 	int mid = left + (right - left) / 2;
    12.  
    13. 	if (a[left] < a[mid])
    14. 	{
    15. 		if (a[right] > a[mid])
    16. 		{
    17. 			return mid;
    18. 		}
    19. 		else if (a[right] < a[left])
    20. 		{
    21. 			return left;
    22. 		}
    23. 		else
    24. 			return right;
    25. 	}
    26. 	else
    27. 	{
    28. 		if (a[right] < a[mid])
    29. 		{
    30. 			return mid;
    31. 		}
    32. 		else if (a[right] > a[left])
    33. 		{
    34. 			return left;
    35. 		}
    36. 		else
    37. 			return right;
    38. 	}
    39. }
    40.  
    41. // 1. hoare版本
    42. int PartSort1(int* a, int left, int right)
    43. {
    44. 	//设置关键字
    45. 	int midi = GetMidIndex(a, left, right);
    46. 	Swap(&a[left], &a[midi]);
    47. 	int keyi = left;
    48.  
    49. 	while (left < right)
    50. 	{
    51. 		//右边先走
    52. 		//找比key小的
    53. 		while (left < right && a[keyi] <= a[right]) //先得判断下标是否合理
    54. 		{
    55. 			right--;
    56. 		}
    57. 		//找比key大的
    58. 		while (left < right && a[keyi] >= a[left])
    59. 		{
    60. 			left++;
    61. 		}
    62.  
    63. 		//交换
    64. 		Swap(&a[left], &a[right]);
    65. 	}
    66. 	//交换重叠位置的数据和key
    67. 	Swap(&a[keyi], &a[right]);
    68.  
    69. 	//将重叠位置返回
    70. 	return right;
    71. }
    72.  
    73. // 2. 挖坑法
    74. int PartSort2(int* a, int left, int right)
    75. {
    76. 	int midi = GetMidIndex(a, left, right);
    77. 	Swap(&a[left], &a[midi]);
    78.  
    79. 	//保存关键值
    80. 	int key = a[left];
    81. 	//设置坑
    82. 	int hole = left;
    83.  
    84. 	//一次排序
    85. 	while (left < right)
    86. 	{
    87. 		//右边找小
    88. 		while (left < right && a[right] > key)
    89. 		{
    90. 			right--;
    91. 		}
    92. 		//找到了将其放入坑中，然后更新坑的位置
    93. 		a[hole] = a[right];
    94. 		hole = right;
    95. 		//左边找大
    96. 		while (left < right && a[left] < key)
    97. 		{
    98. 			left++;
    99. 		}
    100. 		a[hole] = a[left];
    101. 		hole = left;
    102. 	}
    103.  
    104. 	//最后把关键数据再放到坑中
    105. 	a[hole] = key;
    106. 	key = right;
    107. 	return key;
    108. }
    109.  
    110. // 3.前后指针版本
    111. int PartSort3(int* a, int left, int right)
    112. {
    113. 	int midi = GetMidIndex(a, left, right);
    114. 	Swap(&a[left], &a[midi]);
    115.  
    116. 	//设置关键数据
    117. 	int keyi = left;
    118. 	//前后指针（下标）
    119. 	int prev = left;
    120. 	int cur = left + 1;
    121. 	
    122. 	//判断cur的合法性
    123. 	while (cur <= right)
    124. 	{
    125. 		//如果cur指的数据小于关键数据且prev不等于cur即可完成交换
    126. 		if (a[cur] < a[keyi] && ++prev != cur)
    127. 		{
    128. 			Swap(&a[cur], &a[prev]);
    129. 		}
    130. 		cur++;
    131. 	}
    132. 	//cur越界之后再次交换prev与key
    133. 	Swap(&a[keyi], &a[prev]);
    134. 	keyi = prev;
    135. 	//返回新的关键位置
    136. 	return keyi;
    137. }
    138.  
    139. void QuickSort(int* a, int begin, int end)
    140. {
    141. 	//递归截止条件
    142. 	if (begin >= end)
    143. 	{
    144. 		return;
    145. 	}
    146. 	
    147. 	//区间的划分
    148. 	int keyi = PartSort3(a, begin, end);
    149. 	//将整个数据划分为[begin, keyi-1] keyi [keyi+1, end]
    150. 	
    151. 	//递归右区间
    152. 	QuickSort(a, begin, keyi - 1);
    153. 	//递归左区间
    154. 	QuickSort(a, keyi + 1, end);
    155.  
    156. }

    优化过后快速排序的时间复杂度最坏的情况下也是O(N*\log N) 

     1.2非递归版本

    由于递归存在风险，递归太深会出现问题，所以我们需要写出快速排序的非递归版本，快速排序的递归版本跟二叉树的前序遍历逻辑相似，那么在非递归版本中我们需要借助一个数据结构来完成非递归版本的快速排序。

    在之前的数据结构中我们学到了一个叫栈的数据结构，它的特点就是先进后出，因此我们可以借助于栈来实现快速排序的非递归版本。​​​​​​​

    在递归的版本中我们通过第一次排序整个区间然后取得一个关键值的位置，通过这个关键值将数据再次分为两个区间，然后依次递归继续排序这两个区间，并且在这两个区间内会再次划分区间，直到全部排序完毕。根据这个特点我们也可以根据栈的特性来进行实现，首先我们创建一个栈，然后先将0存放在栈中，再将9存放在栈中，那么就可以通过0和9来访问数据了，如果栈不为空，我们就取栈顶的元素9作为右下标，然后将其移除，再取栈顶元素0作为左下标，然后经过一次排序，得到了新的关键值，那么这个关键值会将区间分为两个部分，前面的部分是[left，keyi-1]，后面的部分是[keyi+1，right]，这时就需要对区间的合法性做出判断，如果left小于keyi-1，那么区间合理，可以继续将left作为左下标，将keyi-1作为右下标继续排序，如果right>keyi+1，那么区间合理，可以继续将keyi+1作为左下标，将right作为右下标继续排序，如果两个条件都不满足那么表示排序完成。

    代码演示： 
    1. // 1. hoare版本
    2. int PartSort1(int* a, int left, int right)
    3. {
    4. 	//设置关键字
    5. 	int midi = GetMidIndex(a, left, right);
    6. 	Swap(&a[left], &a[midi]);
    7. 	int keyi = left;
    8.  
    9. 	while (left < right)
    10. 	{
    11. 		//右边先走
    12. 		//找比key小的
    13. 		while (left < right && a[keyi] <= a[right]) //先得判断下标是否合理
    14. 		{
    15. 			right--;
    16. 		}
    17. 		//找比key大的
    18. 		while (left < right && a[keyi] >= a[left])
    19. 		{
    20. 			left++;
    21. 		}
    22.  
    23. 		//交换
    24. 		Swap(&a[left], &a[right]);
    25. 	}
    26. 	//交换重叠位置的数据和key
    27. 	Swap(&a[keyi], &a[right]);
    28.  
    29. 	//将重叠位置返回
    30. 	return right;
    31. }
    32.  
    33. //快速排序的非递归版本
    34. void QuickSortNonR(int* a, int begin, int end)
    35. {
    36. 	//创建栈
    37. 	Stack st;
    38. 	StackInit(&st);
    39.  
    40. 	//先将整个区间放入栈
    41. 	StackPush(&st, begin);
    42. 	StackPush(&st, end);
    43. 	
    44. 	//进行排序
    45. 	while (!StackEmpty(&st))
    46. 	{
    47. 		//取栈顶元素作为右下标
    48. 		int right = StackTop(&st);
    49. 		//删除栈顶元素
    50. 		StackPop(&st);
    51.  
    52. 		//取栈顶元素作为左下标
    53. 		int left = StackTop(&st);
    54. 		//删除栈顶元素
    55. 		StackPop(&st);
    56.  
    57. 		//进行一次排序
    58. 		int keyi = PartSort1(a, left, right);
    59.  
    60. 		//对获得的keyi是否合理进行判断
    61. 		if (left < keyi - 1)
    62. 		{
    63. 			//重新将新的区间放入栈中
    64. 			//注意：顺序不能交换
    65. 			StackPush(&st, left);
    66. 			StackPush(&st, keyi - 1);
    67. 		}
    68. 		if (right > keyi + 1)
    69. 		{
    70. 			//重新将新的区间放入栈中
    71. 			//注意：顺序不能交换
    72. 			StackPush(&st, keyi + 1);
    73. 			StackPush(&st, right);
    74. 		}
    75. 	}
    76.  
    77. 	StackDestroy(&st);
    78. }

    注意：这里的先放左区间和先放右区间跟后面的代码是要呼应的，顺序不能随便更改。

    在这里我就不展示栈接口的代码了，大家可以去栈和队列 这一篇博客找源码。

    快速排序的特性总结：

    1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排
    2. 时间复杂度：O(N*logN)
    3. 空间复杂度：O(logN)
    4. 稳定性：不稳定

     

    朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！ 

  • 相关阅读:
    Linux_一款好用的查看系统信息的桌面软件_包名hardinfo、软件名system profiler and Benchmark
    io多路复用：select、poll和epoll
    Netflow相关技术
    C++面向对象程序设计 - 构造函数
    python的标识符命名规则，保留字表
    程序员究竟是搞技术的，还是做工程的？
    解决Docker安装MySQL不区分大小写问题
    Golang 并发机制 CSP模型
    公司大数据智能管理平台密码不正确 Hue平台进不去
    【语音通信】语音通信系统包括语音硬件采样，抽样量化，PCM编码解码模块，FIR滤波，QPSK调制解调模块，语音增强模块以及语音信号还原
  • 原文地址：https://blog.csdn.net/Yikefore/article/details/132753735