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

快排3种递归方法实现及优化（动图详解）_快速排序递归写法

作者：小丑西瓜9 | 2024-04-27 22:35:17

赞

踩

快速排序递归写法

快速排序介绍：

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

        这里我以升序为例。

        简单来说：一趟排序的本质实际上是将一个或几个数据放到它应该在的位置上。

例如：冒泡排序：每一趟都能将最大的数放到最后的位置。

插入排序：每次插入的数与前面比较，满足条件就插入，不满足就移动。

选择排序：每次选出最大/最小放到最前面或最后面。

堆排序：堆顶可以得到最值，与最后的元素交换后，使得这个最值排在正确位置。向下调整是为了下一次的排序。

而对于快速排序：是先用keyi（下标）标记数组中的一个位置，对于key=arr[keyi]，比它小的放到都它的左边，比它大的都放到它的右边，完成这样的一趟排序，key的位置就是它最终的位置。

然后再通过递归，对key左右分别进行快排。

Hoare方法实现

 为了方便讲解，我们先将keyi=left，使得每次key都是最左边的元素。

并用left和right分别标记数组的最左/右端。（左边为key，右边先找，后续讲解原因）。

        对于1-10的十个数，我们第一趟快排的目的是将6排到下标为5的位置上，并且保证它左边的数都小于6，右边的数都大于6.（这是为了保证，分别对其左右两端排序后，连接上这个6，整体的数组为升序，从而达到排序目的）。

        right从最右端开始找比key==6小的数，找不到就--right，直到用right标记小的这个数。

right找到小后，left开始从左边找比key==6大的数，找不到就++left。只要满足left<right就可以一直找，直到left和right相遇。

        然后将相遇点的数与key交换，此时key就来到了正确的位置。因为刚刚left和right查找并交换的过程，使得比key大的数都到了key左边，而比key小的数也交换到了右边。

  1. void QuickSort(int* arr, int left,int right)
  2. {
  3. 	int keyi = left;
  4.  
  5. 	while (left < right)
  6. 	{
  7.  
  8. 		//先从右边开始找
  9. 		while ((left<right) && arr[right] >= arr[keyi])//右边找小
  10. 		{
  11. 			--right;
  12. 		}
  13. 		while ((left<right) && arr[left] <= arr[keyi])//左边找大
  14. 		{
  15. 			++left;
  16. 		}
  17.  
  18.  
  19. 		Swap(&arr[left], &arr[right]);
  20. 	}
  21. 	//出来后left == right ，交换它与key
  22. 	Swap(&arr[left], &arr[keyi]);
  23. 	keyi = left;//此时keyi在正确的位置
  24.  
  25.  
  26. }

当然，注意一点，最后交换了重合位置与key的值之后，还要让keyi=left，更新一下keyi的位置，便于后续递归。

观察打印后的结果，6排到了正确的位置，比它小的在它左边，比它大的在它右边。 

递归实现key左右两端快排

我们实现快排有3个参数，一个是指向数组第一个元素的指针，另外是下标left和right。

为了对key左右分别递归快排，arr数组不变，需要记录左右两部分各自的left和right位置。

但是因为left和right在排序过程中会改变，因此可以定义begin和end来保存起始和结束的位置。

然后对 [begin,keyi-1] 和 [keyi+1,end]分别递归进行快排。

 当排序区间[left,right]只有一个元素或没有元素时返回。即left>=right时。

  1. void QuickSort(int* arr, int left,int right)
  2. {
  3. 	if (left >= right)
  4. 	{
  5. 		return;
  6. 	}
  7.  
  8. 	int begin = left;
  9. 	int end = right;
  10.  
  11. 	int keyi = left;
  12.  
  13. 	while (left < right)
  14. 	{
  15.  
  16. 		//先从右边开始找
  17. 		while ((left<right) && arr[right] >= arr[keyi])//右边找小
  18. 		{
  19. 			--right;
  20. 		}
  21. 		while ((left<right) && arr[left] <= arr[keyi])//左边找大
  22. 		{
  23. 			++left;
  24. 		}
  25.  
  26. 		Swap(&arr[left], &arr[right]);
  27. 	}
  28. 	//出来后left == right ，交换它与key
  29. 	Swap(&arr[left], &arr[keyi]);
  30. 	keyi = left;//此时keyi在正确的位置
  31.  
  32. 	QuickSort(arr, begin, keyi - 1);
  33. 	QuickSort(arr, keyi + 1, end);
  34.  
  35. }

缺陷：

有一个要注意的点，加入数组中不止一个值为6，当right找小时不能停下，否则当left也为6时，就会产生2个6一直交换，66...66...66....  导致死循环，因此必须严格找小/大。

还有一件事，right找小时不能闷着头找，一直--，同时还要保证left<right。

时间复杂度分析 

最优情况：O(NlogN)

假设每次选到的left位置的key都是这个数组中大小处于中间位置的数据，那么可以将它左右两边的n-1个数据平均分成两组，然后递归快排。

这两边的元素若仍满足，可以再对n-3个分成4组。（此时又排好了2个）

 对于100W个数据，可以分出来约20层，每层有2^n组，每组可以额外少排2^(n-1)次方个数，当然还要加上之前的，大约是2^n个。

换句话说，对于快排整体来说，总共要递归20层，每层大概有n个（实际上比n小一点）元素，因此其时间复杂度可认为是O(NlogN)

最坏情况：O(N^2)

当数组已经是有序（不论升序还是降序），此时keyi标记的数据是数组中的max或min，在进行下一层递归时，一侧为0个元素，另外一侧为n-1个元素，也就是说，要递归N层！

首先，N足够大时，递归N层会导致栈溢出，程序直接崩掉。

然后，这个快速排序就退化成了冒泡排序 ，第一层遍历N个，第二层N-1个，……直到最后1个。

为等差数列，计算后时间复杂度为O(N)。

缺点分析及优化方法：

一个是代码实现上需要注意的几点，是否出现死循环/越界，还有一个优化点就是有序数组退化的问题，时间复杂度大，且可能导致栈溢出。

这些问题的本质是因为我们默认keyi的位置是left，当知到默认为left时，我们当然可以通过有序数组的特殊例子来“推翻”快速排序。下面给出2中优化方法。

随机数优化法：

随机数优化方法就是keyi的位置不固定为left，而是[left,right]中的任一位置，这样就可以嘴大尺度避免有序的特殊情况，（当然顺序的情况也会出现，但概率极低，只有数组有序，且随机到left或right时才会出现）。

这里可以改为   keyi = left +rand() %(right-left+1),得到[0,right-left],再加上left，范围是[left,right]

  1. void QuickSort(int* arr, int left,int right)
  2. {
  3. 	if (left >= right)
  4. 	{
  5. 		return;
  6. 	}
  7.  
  8. 	int begin = left;
  9. 	int end = right;
  10.  
  11. 	  //随机数法，得到一个下标
  12. 	int rand = Qsortrand(arr, left, right);
  13. 	Swap(&arr[left], &arr[rand]);
  14. 	
  15.  
  16. 	int keyi = left;
  17.  
  18. 	while (left < right)
  19. 	{
  20.  
  21. 		//先从右边开始找
  22. 		while ((left<right) && arr[right] >= arr[keyi])//右边找小
  23. 		{
  24. 			--right;
  25. 		}
  26. 		while ((left<right) && arr[left] <= arr[keyi])//左边找大
  27. 		{
  28. 			++left;
  29. 		}
  30.  
  31. 		Swap(&arr[left], &arr[right]);
  32. 	}
  33. 	//出来后left == right ，交换它与key
  34. 	Swap(&arr[left], &arr[keyi]);
  35. 	keyi = left;//此时keyi在正确的位置
  36.  
  37. 	QuickSort(arr, begin, keyi - 1);
  38. 	QuickSort(arr, keyi + 1, end);
  39.  
  40. }

用区间的开始left，加上范围在区间的差（right-left）内的随机数，使得随机数落在区间范围内。

得到随机数的下标后，它的值可能是数组中的任意大小，因此便于后面的递归排序。

交换 left 与 rand两个值，keyi仍然指向left，但此时arr[left]已经是随机的了

三数取中优化法：

因为随机数法还是有可能选到最大/最小的数据的，因此又有人提出来三数取中法。

即在arr[left]/arr[right]/arr[mid]中选出中间大小的数，既保证了随机选择，又避免了取到最大/最小，进一步提升了效率。

  1. //三数取中法优化快排
  2. int GetMidNumi(int* arr, int left, int right)
  3. {
  4. 	int mid = (left + right) / 2;
  5.  
  6. 	//  先取出 最左端、最右端、中间的数据
  7. 	//  比较出大小后返回的是下标
  8. 	if (arr[left] > arr[right])
  9. 	{
  10. 		if (arr[mid] < arr[right])
  11. 		{
  12. 			return right;
  13. 		}
  14. 		else if (arr[left] > arr[mid])
  15. 		{
  16. 			return mid;
  17. 		}
  18. 		else
  19. 		{
  20. 			return left;
  21. 		}
  22. 	}
  23. 	else
  24. 	{
  25. 		if (arr[left] > arr[mid])
  26. 		{
  27. 			return left;
  28. 		}
  29. 		else if (arr[right] > arr[mid])
  30. 		{
  31. 			return mid;
  32. 		}
  33. 		else
  34. 		{
  35. 			return right;
  36. 		}
  37. 	}
  38. }

 返回的是3个数中  中间大小的下标。

 接收后，同样将left与这个中间数的值交换，这样left指向的值就是随机的，且不为最大/最小。

经过上面的优化，避免了最坏情况，快排的时间复杂度可认为是O(NlogN)。

左key右先走的解释：

1、普通情况：此时，right找小，找到后停下，left找大，找到后停下，互相交换，此时left和right没有相遇，一直重复上述过程。

2、左遇右：此时右边已经停下，则arr[right]<key是成立的，左边一直找大，没有找到，直到与right相遇，此时二者都指向一个比key小的数。

3、右遇左：上一次普通情况交换数据后，arr[left]<key,此时右边找小，没找到，直到与left重合，此时二者都指向一个比key小的值。（这里有一种特殊情况，如果是升序，右边也找不到小，直到与左边重合，此时都指向第一个元素）。

找到key该在的位置后，交换arr[keyi]与这个位置的值即可排好key。

如果是左key左先走，在一个比key大的位置停留，若此时右边再走，与left重合，二者指向的值比key大，再交换就发生错误了。

挖坑法：

整体思想上与Hoare方法类似，效率也差不多，但可能比较好理解一点。

 先将arr[left]拿出来保存在tmp中，此时left的位置可以看作是一个坑，用hole标记，之后的操作就是不断的填坑，挖坑，再填坑。

        因为坑在左边，所以从右边开始找小，找到后arr[hole]=arr[right],将右边这个小于key的值填入坑中，然后hole=right，更新坑的位置，然后坑就在右边了。

之后不断重复，因为left和right一定有一个与hole重合，所以left==right时，hole也在相同的位置。因此arr[hole]=tmp最终把tmp的保存的值填入坑中即可。然后递归hole两侧进行后续快排。

  1. //  挖坑法快排
  2. void QsortHole(int* arr, int left, int right)
  3. {
  4. 	if (left >= right)
  5. 	{
  6. 		return;
  7. 	}
  8.  
  9. 	int begin = left;
  10. 	int end = right;
  11.  
  12. 	int mid = GetMidNumi(arr, left, right);
  13. 	Swap(&arr[mid], &arr[left]);
  14. 	int tmp = arr[left];
  15. 	int hole = left;
  16.  
  17. 	while (left < right)
  18. 	{
  19. 		//  右边找小
  20. 		while (left < right && arr[right] >= tmp)
  21. 		{
  22. 			right--;
  23. 		}
  24. 		//  右边填左边的坑
  25. 		arr[hole] = arr[right];
  26. 		hole = right;
  27.  
  28. 		//  左边找大
  29. 		while (left < right && arr[left] < tmp)
  30. 		{
  31. 			++left;
  32. 		}
  33. 		//   左边填右边的坑
  34. 		arr[hole] = arr[left];
  35. 		hole = left;
  36. 		
  37. 	}
  38. 	arr[hole] = tmp;
  39.  
  40. 	QsortHole(arr, begin, hole - 1);
  41. 	QsortHole(arr, hole + 1, end);
  42.  
  43. }

要注意的是一开始要用tmp保存值，填坑过程为赋值，并且hole也要更新。

快慢指针（下标）法：

 利用prev、cur两个数组下标，也可看作是指针，二者本质相同。

起始状态，prev和key都指向最左边的元素，cur指向下标为1的。

然后先用cur来遍历整个数组找小，如果arr[cur]>=key,则该位置较大，不用交换++cur；如果arr[cur]<key,该位置较小，需要交换。

先++prev，意义是要调整的前面的，较小的数据数+1，因此prev要先+1.然后Swap(&arr[prev],&arr[cur])。

重复上述过程。

通过观察我们可以发现，prev与cur之间如果存在数据，那么这些数据都是大于key时cur多走的。

 当cur>key时，cur就遍历完了整个数组，将所有小于key的值都交给了arr[prev]，此时prev及其左侧的数均<key(起始位置除外)，最后再交换一下起始位置和当前prev的位置。

最后再以prev为分隔，分别递归两侧，进行后续快排。

  1. //  快慢指针法快排
  2. void QSortByPtrs(int* arr, int left, int right)
  3. {
  4. 	if (left >= right)
  5. 	{
  6. 		return;
  7. 	}
  8.  
  9. 	int begin = left;
  10. 	int end = right;
  11.  
  12. 	int midi = GetMidNumi(arr, left, right);
  13. 	printf("%d\n", arr[midi]);
  14. 	Swap(&arr[left], &arr[midi]);
  15. 	int key = arr[left];
  16.  
  17. 	int cur = left + 1;
  18. 	int prev = left;
  19. 	while (cur <= right)
  20. 	{
  21. 		while (cur <= right && arr[cur] >= key)
  22. 		{
  23. 			++cur;
  24. 		}
  25. 		if (cur <= right && arr[cur] < key)
  26. 		{
  27. 			++prev;
  28. 			if (prev != cur)
  29. 				Swap(&arr[prev], &arr[cur]);
  30.  
  31. 			++cur;
  32. 		}
  33. 	}
  34. 	//cur遍历完后，prev指向的位置就是key的最终位置
  35. 	Swap(&arr[prev], &arr[begin]);
  36.  
  37. 	//递归实现后续快排
  38. 	QSortByPtrs(arr, begin, prev - 1);
  39. 	QSortByPtrs(arr, prev+1, end);
  40. }

要注意的是cur和left不能只是1和0，而是要根据left去取值，否则对右边的元素递归会产生错误。

++cur前保证cur<=right,防止越界访问。

最后将begin位置与prev交换，完成一趟快排，然后递归实现后续快排。

递归过程封装：

本文讲了Hoare、挖坑法、快慢指针法三种递归方法完成快速排序，它们的递归过程是相同的，可以将递归结束条件和后续递归过程封装起来，然后在中间调用3种方法的函数，使逻辑更清晰。

 封装中只写结束条件和递归过程。并用一个keyi接收之前3种方法排序后key的下标位置。

1、Hoare方法返回keyi的位置。

2、挖坑法返回最终坑的位置。

3、快慢指针法返回prev的位置。

返回排好的那个数的位置后，再用left，keyi，right进行递归，从而完成快排的递归封装。

目录

快速排序介绍：

Hoare方法实现

递归实现key左右两端快排

缺陷：

时间复杂度分析 

最优情况：O(NlogN)

最坏情况：O(N^2)

缺点分析及优化方法：

随机数优化法：

三数取中优化法：

左key右先走的解释：

挖坑法：

快慢指针（下标）法：

递归过程封装：

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

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

  

闽ICP备14008679号