• 【数据结构】交换排序之冒泡排序与快速排序

    承接上文：

    (32条消息) 【数据结构】常见排序之插入排序与选择排序_vpurple__的博客-CSDN博客https://blog.csdn.net/vpurple_/article/details/126568614?spm=1001.2014.3001.5502icon-default.png?t=M85Bhttps://blog.csdn.net/vpurple_/article/details/126568614?spm=1001.2014.3001.5502

    目录

    承接上文：

    交换排序

    1.冒泡排序

    2.快速排序递归版

    1.1. hoare版本

    1.1.1hoare1.0版本

    1.1.2.hoare2.0版本（三数取中法+使得相遇点大小可控

    1.1.3小区间优化

    1.2.挖坑法

    1.2.1.挖坑法思路解析

    1.2.2.挖坑法完整代码

    1.3.前后指针法

    1.3.1前后指针法思路解析

    1.3.2前后指针法完整代码

    3.快速排序非递归版

    3.1.快速排序非递归版思路解析

    3.2.快速排序非递归版完整代码

    最后

    交换排序

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

    1.冒泡排序

    冒泡排序动图演示：

     冒泡排序完整代码：

    1. //冒泡排序
    2. void BubbleSort(int* a, int n)
    3. {
    4. 	//排降序
    5. 	for (int j = 0; j < n; j++)
    6. 	{
    7. 		for (int i = 0; i < n-j; i++)
    8. 		{
    9. 			if (a[i] < a[i + 1])
    10. 			{
    11. 				swap(&a[i], &a[i + 1]);
    12. 			}
    13. 		}
    14. 	}
    15. }

    冒泡排序的特性总结：

    1. 冒泡排序是一种非常容易理解的排序

    2. 时间复杂度：O(N^2)

    3. 空间复杂度：O(1)

    4. 稳定性：稳定

    2.快速排序递归版

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

           上述为快速排序递归实现的主框架，与二叉树前序遍历规则非常像，在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后续只需分析如何按照基准值来对区间中数据进行划分的方式即可。

    子区间如何有序？ 将子问题进行递归，类似二叉树前序遍历。

    1. // 假设按照升序对array数组中[left, right]区间中的元素进行排序
    2. void QuickSort(int array[], int left, int right)
    3. {
    4.  if(right <= left)
    5.  return;
    6.  
    7.  // 按照基准值对array数组的 [left, right]区间中的元素进行划分
    8.  int div = partion(array, left, right);
    9.  
    10.  // 划分成功后以div为边界形成了 [left, div-1] div [div+1, right]
    11.  // 递归排[left, div)
    12.  QuickSort(array, left, div-1);
    13.  
    14.  // 递归排[div+1, right)
    15.  QuickSort(array, div+1, right);
    16. }

    将区间按照基准值划分为左右两半部分的常见方式有：

    1.1. hoare版本

    1.1.1hoare1.0版本

    hoare演示动图如下：

    我们先进行单趟排序：

    1. 选择一个 key , 一般是第一个或者最后一个。
    2. 单趟排序最后，要求小的数在key左边，大的数在key右边。

    单趟排序的作用：

    1. key已经找到了最终位置，把key排好。
    2. 分割出了两个子区间，左区间比key小，右区间比key大，如果子区间有序，那整体有序。

     hoare版本初代代码解析如下：

    hoare版本初代代码如下：

    1. //返回最终基准值下标
    2. int partion(int arr[], int left, int right)
    3. {
    4. 	//选最左边数k为基准，两边开始走，比k大到右边，比k小到左边
    5. 	int k = left;
    6. 	
    7. 	while (left < right)
    8. 	{
    9. 		if (arr[left] > arr[k] && arr[right] < arr[k])
    10. 		{
    11. 			swap(&arr[left], &arr[right]);
    12. 		}
    13. 	
    14. 		if (arr[left] <= arr[k])
    15. 		{
    16. 			left++;
    17. 		}
    18.  
    19. 		if (arr[right] >= arr[k])
    20. 		{
    21. 			right--;
    22. 		}
    23.  
    24. 	}
    25.  
    26. 	if (arr[left] > arr[k])
    27. 	{
    28. 		left--;
    29. 	}
    30.  
    31. 	swap(&arr[k], &arr[left]);
    32.  
    33. 	return left;
    34. }

    1.1.2.hoare2.0版本（三数取中法+使得相遇点大小可控

    可采用三数取中法优化进行基准值的选择，从而有效解决递归层度太深的问题。

    三数取中法代码如下：

    1.  
    2. //优化 三数取中法
    3. int mid_ThreeNum(int arr[], int left, int right)
    4. {
    5. 	int mid = (left + right) / 2;
    6. 	if (arr[left] < arr[mid])
    7. 	{
    8. 		if (arr[mid] < arr[right])
    9. 		{
    10. 			return mid;
    11. 		}
    12. 		else//mid最大
    13. 		{
    14. 			if (arr[left] > arr[right])
    15. 			{
    16. 				return left;
    17. 			}
    18. 			else
    19. 			{
    20. 				return right;
    21. 			}
    22. 		}
    23. 	}
    24. 	else//arr[left]>arr[mid] 
    25. 	{
    26. 		if (arr[left] < arr[right])
    27. 		{
    28. 			return left;
    29. 		}
    30. 		else//left最大
    31. 		{
    32. 			if (arr[mid] > arr[right])
    33. 			{
    34. 				return mid;
    35. 			}
    36. 			else
    37. 			{
    38. 				return right;
    39. 			}
    40. 		}
    41. 	}
    42. }

    使得相遇点大小可控

           如果最左边的数做key,就要保证相遇位置比key小，从而使得key和相遇点交换位置之后仍然满足key左边的数比key小。

           而相遇的位置如何保持比key小呢 —— 左边第一个值做key时，R先走，每次交换过后也是R走 。

            以此类推当右边第一个值做key时，L先走，相遇点要比key大。

    原因分析如下：

    1. R先停，L与R相遇，此时的相遇位置比key小。
    2. L先停（这里的L先停是L与R交换后的停，此时L指向的数据已被交换），R与L相遇，此时相遇位置比key小。

    所以可以优化为：

     hoare2.0版本完整代码如下：

    1. int partion0(int arr[], int left, int right)
    2. {
    3. 	//选最左边数k为基准，两边开始走，比k大到右边，比k小到左边
    4. 	int k = mid_ThreeNum(arr, left, right);
    5. 	swap(&arr[left], &arr[k]);
    6. 	k = left;
    7. 	while (left < right)
    8. 	{
    9. 		while(arr[right] >= arr[k] && left < right)
    10. 		{
    11. 			right--;
    12. 		}
    13. 		
    14. 		while (arr[left] <= arr[k]&&left
    15. 		{
    16. 			left++;
    17. 		}
    18.  
    19. 		if ( left < right)
    20. 		{
    21. 			swap(&arr[left], &arr[right]);
    22. 		}
    23. 	}
    24. 	
    25. 	swap(&arr[k], &arr[left]);
    26. 	return left;
    27. }

    1.1.3小区间优化

           快速排序类似于二叉树的形态，在调用的最后一层占一半的调用次数，倒数第二层占四分之一的调用次数依次类推，可得倒数三层合计可占百分之八十以上的递归调用次数。

            可以选择在倒数8层的时候采用插入排序，可有效减少递归深度。

    1. // 假设按照升序对array数组中[left, right]区间中的元素进行排序
    2. void QuickSort(int array[], int left, int right)
    3.  {
    4. 	
    5. 	if (right - left <= 8)
    6. 	{
    7. 		InsertSort(array + left, right - left + 1);
    8. 	}
    9. 	else
    10. 	{
    11. 		// 按照基准值对array数组的 [left, right]区间中的元素进行划分
    12. 		int div = partion0(array, left, right);
    13.  
    14. 		// 划分成功后以div为边界形成了左右两部分 [left, div] 和 [div+1, right]
    15. 		// 递归排[left, div]
    16. 		QuickSort(array, left, div - 1);
    17.  
    18. 		// 递归排[div+1, right]
    19. 		QuickSort(array, div + 1, right);
    20. 	}
    21. }

    1.2.挖坑法

    1.2.1.挖坑法思路解析

    挖坑法动图演示如下：

           令最右边为key,第一个坑位就在最右边。最右边为坑左边先走，找大，把找出的大的值填到右边的坑位去，然后左边这个位置就为坑，右边走，找小，把找出小的值填到左边的坑位，然后右边这个新的位置就是新的坑，以此类推……当左右边相遇时，此时相遇的位置就是最后一个坑位，把key中的值填入坑位即可，单趟排序结束，依次递归即可。

    1.2.2.挖坑法完整代码

    1. //挖坑法
    2. int partion2(int* arr, int begin, int end)
    3. {
    4. 	//三数取中
    5. 	int k = mid_ThreeNum(arr, begin, end);
    6.  
    7. 	//令最右边为坑位
    8. 	int key = arr[k];
    9. 	swap(&arr[k], &arr[end]);
    10. 	k = end;//k指向的就是坑位
    11.  
    12. 	//begin找大 end找小
    13. 	while (begin < end)
    14. 	{
    15. 		while (begin < end)
    16. 		{
    17. 			if (arr[begin] > key)
    18. 			{
    19. 				arr[k] = arr[begin];
    20. 				k = begin;
    21. 				break;
    22. 			}
    23. 			begin++;
    24. 		}
    25.  
    26. 		while (begin < end)
    27. 		{
    28. 			if (arr[end] < key)
    29. 			{
    30. 				arr[k] = arr[end];
    31. 				k = end;
    32. 				break;
    33. 			}
    34. 			end--;
    35. 		}
    36.  
    37. 	}
    38. 	arr[k] = key;
    39. 	return k;
    40. }
    41.  
    42. // 假设按照升序对array数组中[left, right]区间中的元素进行排序
    43. void QuickSort(int array[], int left, int right)
    44.  {
    45. 	
    46. 	if (right - left <= 8)
    47. 	{
    48. 		InsertSort(array + left, right - left + 1);
    49. 	}
    50. 	else
    51. 	{
    52. 		// 按照基准值对array数组的 [left, right]区间中的元素进行划分
    53. 		int div = partion0(array, left, right);
    54.  
    55. 		// 划分成功后以div为边界形成了左右两部分 [left, div] 和 [div+1, right]
    56. 		// 递归排[left, div]
    57. 		QuickSort(array, left, div - 1);
    58.  
    59. 		// 递归排[div+1, right]
    60. 		QuickSort(array, div + 1, right);
    61. 	}
    62. }

    1.3.前后指针法

    1.3.1前后指针法思路解析

    前后指针法演示动图：

    cur一直在找小

    prev有两种状态：

    1. 紧跟着cur.
    2. prev与cur间隔着比key大的值

           当key在最右边时，cur和prev从最左边为起点，如果值都比key小的话，cur和prev同时前进，prev找大，找到大停止，随后cur找小，找到小停止，交换cur和prev所指向的值，随后继续当cur到最右边key的位置时，停止前进，prev继续找大，找大停止后，prev和cur（key）交换,完成单趟排序，依次递归即可。

           当key在最左边时，prev=0,cur=1,如果值都比key小的话，cur和prev同时前进，prev找大，找到大停止，随后cur找小，找到小停止，交换cur和prev所指向的值，随后继续当cur到最右边key的位置时，停止前进，将prev指向的值和最左边key中的值交换即可。完成单趟排序，依次递归完成排序。

    1.3.2前后指针法完整代码

    key在最左边（最简洁的写法）：

    1. int partion5(int* arr, int left, int right)
    2. {
    3. 	int mid = mid_ThreeNum(arr, left, right);
    4. 	swap(&arr[mid], &arr[left]);
    5. 	int key = arr[left];
    6.  
    7. 	int prev = left;//找大
    8. 	int cur = left+1;//找小
    9.  
    10. 	while (cur <= right)
    11. 	{
    12. 		if (arr[cur] < key && ++prev != cur)
    13. 		{
    14. 			swap(&arr[cur], &arr[prev]);
    15. 		}
    16. 		cur++;
    17. 	}
    18. 	swap(&arr[prev], &arr[left]);
    19.  
    20. 	return prev;
    21. }
    22.  
    23. // 假设按照升序对array数组中[left, right]区间中的元素进行排序
    24. void QuickSort(int array[], int left, int right)
    25.  {
    26. 	
    27. 	if (right - left <= 8)
    28. 	{
    29. 		InsertSort(array + left, right - left + 1);
    30. 	}
    31. 	else
    32. 	{
    33. 		// 按照基准值对array数组的 [left, right]区间中的元素进行划分
    34. 		int div = partion0(array, left, right);
    35.  
    36. 		// 划分成功后以div为边界形成了左右两部分 [left, div] 和 [div+1, right]
    37. 		// 递归排[left, div]
    38. 		QuickSort(array, left, div - 1);
    39.  
    40. 		// 递归排[div+1, right]
    41. 		QuickSort(array, div + 1, right);
    42. 	}
    43. }

    key在最右边（便于理解的写法）：

    1. int partion4(int* arr, int left, int right)
    2. {
    3. 	int mid = mid_ThreeNum(arr, left, right);
    4. 	swap(&arr[mid], &arr[right]);
    5. 	int key = arr[right];
    6. 	
    7. 	int prev = left;//找大
    8. 	int cur = left;//找小
    9.  
    10. 	while (cur < right && prev < right)
    11. 	{
    12. 		//如果都小于key就一起走
    13. 		while (cur < right && prev < right && arr[cur] <= key && arr[prev] <= key)
    14. 		{
    15. 			cur++;
    16. 			prev++;
    17. 		}
    18.  
    19. 		//cur先走
    20. 		while (arr[cur] > key && cur < right)//cur==right停止
    21. 		{
    22. 			cur++;
    23. 		}
    24. 		while (arr[prev] < key && prev < right)
    25. 		{
    26. 			prev++;
    27. 		}
    28. 		if(cur <= right && prev <= right )
    29. 			swap(&arr[prev], &arr[cur]);
    30. 	}
    31.  
    32. 	return prev;
    33. }
    34.  
    35. // 假设按照升序对array数组中[left, right]区间中的元素进行排序
    36. void QuickSort(int array[], int left, int right)
    37.  {
    38. 	
    39. 	if (right - left <= 8)
    40. 	{
    41. 		InsertSort(array + left, right - left + 1);
    42. 	}
    43. 	else
    44. 	{
    45. 		// 按照基准值对array数组的 [left, right]区间中的元素进行划分
    46. 		int div = partion0(array, left, right);
    47.  
    48. 		// 划分成功后以div为边界形成了左右两部分 [left, div] 和 [div+1, right]
    49. 		// 递归排[left, div]
    50. 		QuickSort(array, left, div - 1);
    51.  
    52. 		// 递归排[div+1, right]
    53. 		QuickSort(array, div + 1, right);
    54. 	}
    55. }

    3.快速排序非递归版

    3.1.快速排序非递归版思路解析

          快速排序的非递归可以通过借助栈来实现：

    (54条消息) 【数据结构】一起来学习栈吧~_vpurple__的博客-CSDN博客icon-default.png?t=M85Bhttps://blog.csdn.net/vpurple_/article/details/126162037?spm=1001.2014.3001.5502      单趟排序的基本思想还是不变的，重点是如何将递归拆解转换为循环，递归改非递归有一个诀窍就是看递归时函数栈帧中储存什么，那么非递归中的栈就保存什么。之前的递归，函数栈帧中存储的是形参，也就是left,right左右区间，所以在栈中存储左右区间下标即可。

          注意：在创建栈最后一定要记得销毁栈，小心内存泄漏。

    3.2.快速排序非递归版完整代码

    1. // 快速排序 非递归实现
    2. void QuickSortNonR(int* a, int left, int right)
    3. {
    4. 	Stack st;
    5. 	StackInit(&st);
    6. 	StackPush(&st, right);
    7. 	StackPush(&st, left);
    8. 	while (!StackEmpty(&st))
    9. 	{
    10. 		int left = StackTop(&st);
    11. 		StackPop(&st);
    12. 		int right = StackTop(&st);
    13. 		StackPop(&st);
    14. 		if (left < right)
    15. 		{
    16. 			int key = partion5(a, left, right);
    17. 			
    18. 			StackPush(&st, key - 1);
    19. 			StackPush(&st, left);
    20. 			StackPush(&st, right);
    21. 			StackPush(&st, key + 1);
    22. 		}
    23. 	}
    24. 	StackDestroy(&st);
    25. }

    最后

        又是摆烂许久的重新回归，好久不见，这里是媛仔！最近我们这边疫情又变得严重了，返校之路遥遥无期啊……在家里还是太容易懈怠了，要加油！！希望这篇文章对你能够有所帮助哦！！还有中秋节快乐，记得吃月饼~

  • 相关阅读:
    前端之HTML超文本标记语言，http协议
    Redis实现延时队列-工具类
    GBase 8c V3.0.0数据类型——安全函数
    【探花交友】保存用户信息、上传用户头像、用户信息管理
    科技型中小企业有哪些?
    python打卡提醒机器人（企业微信）
    【C语言】带头双向循环链表（list）详解（定义、增、删、查、改）
    element plus Message方法手动关闭，close方法使用
    SpringBoot+Vue实现前后端分离的餐饮点餐系统
    slam 14讲笔记
  • 原文地址：https://blog.csdn.net/vpurple_/article/details/126788458