• 【C语言简单实现数据结构】排序之交换排序和归并排序

     心有所向，日复一日，必有精进。 

     

     

     

    目录

    前言

    一、交换排序

     冒泡排序

    算法思想： 

     代码实现：

     冒泡排序的特性总结：

    快速排序

    Hoare版本：

     挖坑法

     前后指针法

    快速排序的特性总结：

    归并排序

     递归实现

     非递归

    归并排序的特性总结：

     

    前言

    常见排序 

     相对于插入排序和选择排序，交换排序和归并排序比较难。

    一、交换排序

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

     冒泡排序

    算法思想： 

    两两进行比较选出二者中最大（或小）值，交换（升序将最大值换到后面，降序将最小值换到后面），每一趟排序最后将 最大（或最小）放在最后，经过n-1趟完成排序，这个过程就像一个一个气泡浮出，称为冒泡排序。

    图片来源于网络，侵删 

     代码实现：

    1. void BubbleSort(int* a, int n){
    2. 	assert(a);
    3. 	for (int j = 0; j < n; j++){
    4. 		//一趟
    5. 		int exchange = 0;
    6. 		for (int i = 0; i < n - 1-j; i++){
    7. 			if (a[i]>a[i + 1]){
    8. 				Swap(&a[i], &a[i + 1]);
    9. 				exchange = 1;
    10. 			}
    11. 		}	
    12. 		if (exchange == 0)
    13. 		{
    14. 			break;
    15. 		}
    16. 	}
    17. }

     冒泡排序的特性总结：

    1. 冒泡排序是一种非常容易理解的排序
    2. 时间复杂度：O(N^2)
    3. 空间复杂度：O(1)
    4. 稳定性：稳定

    快速排序

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

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

    单趟：

    1. 选择key（一般是第一个或者最后一个）。
    2. 单趟排序要求小的在key左大的在key右面（以升序为例） 。

    Hoare版本：

    选出一个key，一般是最左边或是最右边的。

    1. 定义一个begin和一个end，begin从左向右走，end从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要bengin先走）。
    2. 在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的数时，将begin和right的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）

    此时key的左边都是小于key的数，key的右边都是大于key的数
     

     单步分析：

    那么如何保证，相遇位置比key要小？

    当左边值做key，右面先走可以保证；

    R停下来，L撞到R相遇。——相遇位置比key小（right找小）

    L停下来，R撞到了L。——相遇位置比key小

    同理，如果让右面第一个做key让左面先走；

    1. // 快速排序hoare版本
    2. int PartSort1(int* a, int left, int right){
    3. 	//单趟
    4. 	int key = left;
    5. 	while (left < right){
    6. //R找小（相等过滤掉！！！）
    7. 		while (left=a[key]){ right--; }
    8. //L找大（相等过滤掉！！！）
    9. 		while (left < right&&a[left] <= a[key]){ left++; }
    10. 		Swap(&a[left], &a[right]);
    11. 	}
    12.     int meeti = left;
    13. 	Swap(&a[meeti], &a[key]);   
    14. 	return meeti;
    15. }

     挖坑法

    类似Hoare版本，但多了坑位，不用交换，思想类似；

      

     代码实现：

    1. // 快速排序挖坑法
    2. int PartSort2(int* a, int left, int right){
    3. 	//单趟
    4. 	int mid = GetMidIndex(a, left, right);
    5. 	Swap(&a[left], &a[mid]);
    6. 	int key = a[left];
    7. 	int hole = left;
    8. 	while (left < right){
    9. 		while (left < right&&a[right] >= key){ right--; }
    10. 		a[hole] = a[right];
    11. 		hole = right;
    12. 		while (left < right&&a[left] <= key){ left++; }
    13. 		a[hole] = a[left];
    14. 		hole = left;
    15. 	}
    16.     a[hole] = key;
    17. 	return hole;
    18. }

     前后指针法

    初始时，per指针指向序列开头，cur指针指向per指针的后一个位置

    cur找小

    per有两种状态：紧跟着cur 和 per在比key大的前面；

    选出一个key，一般是最左边或是最右边的。

    1. 起始时，per指针指向序列开头，cur指针指向per+1。
    2. 若cur指向的内容小于key，则per先向后移动一位，然后交换per和cur指针指向的内容，然后cur指针++；若cur指向的内容大于key，则cur指针直接++。如此进行下去，直到cur到达end位置，此时将key和++per指针指向的内容交换即可。

    经过一次单趟排序，最终也能使得key左边的数据全部都小于key，key右边的数据全部都大于key。

     

    1. // 快速排序前后指针法
    2. int PartSort3(int* a, int left, int right){
    3. 	int mid = GetMidIndex(a, left, right);
    4. 	Swap(&a[left], &a[mid]);
    5. 	int key = left;
    6. 	int per, cur;
    7. 	per = left;
    8. 	cur = left + 1;
    9. 	while (cur <= right){
    10. 		if (a[cur] < a[key] && ++per != cur){
    11. 			Swap(&a[cur], &a[per]);
    12. 		}
    13. 		cur++;
    14. 	}
    15. 	Swap(&a[per], &a[key]);
    16. 	return per;
    17. }

    快速排序单趟排序

    1. 使key已经到了最终位置；
    2. 分出了两个子区间，如果子区间有序，整体有序；

    子区间如何有序？子区间递归！（类似于二叉树）。

    1. void QuickSort(int *a, int left, int right){
    2. 	if (right <= left)return;
    3. 	int keyi = PartSort1(a,left,right);
    4. 	QuickSort(a,0,keyi-1);
    5. 	QuickSort(a, keyi+1, right);
    6. }

    时间复杂度：

    递归深度：logN;但是我们发现如果接近满二叉树，即每次选数都是中间位置，这时候的复杂度为O(NlogN);

      如果有序？

     有序递归深度是N，在极端情况下O(N)；

    如果选key固定，如果数据有序在递归中容易出现栈溢出；

    优化选Key的逻辑：

    1. 随机选一个位置的key；
    2. 针对有序的情况，选正中间的值作为key；（如果接近有序是不是可能不太好，中间值恰巧比较小呢？）
    3. 三数取中，第一个，中间位置，最后一个 选出中间值

     代码实现三数取中：

    1. int GetMidIndex(int* a, int left, int right)
    2. {
    3. 	int mid = left + (right - left) / 2;
    4. 	if (a[left] < a[mid])
    5. 	{
    6. 		if (a[mid] < a[right])
    7. 		{
    8. 			return mid;
    9. 		}
    10. 		else if (a[left] > a[right])
    11. 		{
    12. 			return left;
    13. 		}
    14. 		else
    15. 		{
    16. 			return right;
    17. 		}
    18. 	}
    19. 	else // a[left] >= a[mid]
    20. 	{
    21. 		if (a[mid] > a[right])
    22. 		{
    23. 			return mid;
    24. 		}
    25. 		else if (a[left] < a[right])
    26. 		{
    27. 			return left;
    28. 		}
    29. 		else
    30. 		{
    31. 			return right;
    32. 		}
    33. 	}
    34. }

     小区间优化

    如图，当我们递归调用后，最后剩下8个元素时候，我们任然需要8次递归来排序 

     最后三层的递归次数大约有80%，如果我们干掉这最后三层递归就好；所以最后的几层我们可以用一个排序，使用插入排序：

    1. void QuickSort(int* a, int begin, int end)
    2. {
    3. 	if (begin >= end)
    4. 	{
    5. 		return;
    6. 	}
    7.  
    8. 	if (end - begin <= 8)
    9. 	{
    10. 		InsertSort(a + begin, end - begin + 1);//插入排序见上章
    11. 	}
    12. 	else
    13. 	{
    14. 		int keyi = PartSort2(a, begin, end);
    15. 		QuickSort(a, begin, keyi - 1);
    16. 		QuickSort(a, keyi + 1, end);
    17. 	}
    18. }

    非递归：

    用栈模拟实现递归，在栈中存放区间；

    栈帧是有限的，在递归调用过多后容易溢出，而数据结构的栈开辟在堆栈上，溢出可能性比较小

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

    快速排序的特性总结：


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

     3. 空间复杂度：O(logN)
     4. 稳定性：不稳定

    二、归并排序

    基本思想：
    归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

     

     递归实现

    1. // 归并排序递归实现
    2. void _MergeSort(int* a, int begin, int end, int* tmp){
    3. 	
    4.  
    5. 	if (begin >= end){
    6. 		return;
    7. 	}
    8. 	int mid = (begin + end) / 2;
    9. 	_MergeSort(a, begin, mid, tmp);
    10. 	_MergeSort(a, mid + 1, end, tmp);
    11. 	 
    12. 	//归并
    13. 	int begin1 = begin, end1 = mid;
    14. 	int begin2 = mid + 1, end2 = end;
    15. 	int i = begin;
    16. 	while (begin1<=end1&&begin2<=end2){
    17. 		if (a[begin1] <= a[begin2]){
    18. 			tmp[i++] = a[begin1++];
    19. 		}
    20. 		else{
    21. 			tmp[i++] = a[begin2++];
    22. 		}
    23. 	}
    24. 	while (begin1 <= end1){
    25. 		tmp[i++] = a[begin1++];
    26. 	}
    27. 	while (begin2 <= end2){
    28. 		tmp[i++] = a[begin2++];
    29. 	}
    30. 	// 拷贝回原数组 -- 归并哪部分就拷贝哪部分回去
    31. 	memcpy(a + begin, tmp + begin, (end - begin + 1)*sizeof(int));
    32. }
    33. void MergeSort(int* a, int n){
    34. 	int* tmp = (int*)malloc(sizeof(int)*n);
    35. 	if (tmp == NULL){
    36. 		perror("malloc fail");
    37. 		return;
    38. 	}
    39. 	
    40. 	_MergeSort(a, 0, n - 1, tmp);
    41. 	free(tmp);
    42. 	tmp = NULL;
    43. }

     非递归

     

     

    1. // 归并排序非递归实现
    2. void MergeSortNonR(int* a, int n){
    3. 	int* tmp = (int*)malloc(sizeof(int)*n);
    4. 	if (tmp == NULL){
    5. 		perror("malloc fail");
    6. 		return;
    7. 	}
    8. 	int gap = 1;
    9. 	while (gap < n){
    10. 		for (int j = 0; j < n; j += 2 * gap){
    11.  
    12.  
    13. 			//归并
    14. 			int begin1 = j, end1 = j + gap - 1;
    15. 			int begin2 = j + gap, end2 = j + 2 * gap - 1;
    16. 			printf("[%d,%d][%d,%d]", begin1, end1, begin2, end2);
    17. 			if (end1 >= n){
    18. 				break; 
    19. 			}
    20. 			if (begin2 >= n){
    21. 				break;
    22. 			}
    23. 			if (end2 >= n){
    24. 				end2 = n - 1;
    25. 			}
    26. 			int i = j;
    27. 			while (begin1 <= end1&&begin2 <= end2){
    28. 				if (a[begin1] <= a[begin2]){
    29. 					tmp[i++] = a[begin1++];
    30. 				}
    31. 				else{
    32. 					tmp[i++] = a[begin2++];
    33. 				}
    34. 			}
    35. 			while (begin1 <= end1){
    36. 				tmp[i++] = a[begin1++];
    37. 			}
    38. 			while (begin2 <= end2){
    39. 				tmp[i++] = a[begin2++];
    40. 			}	
    41. 			// 拷贝回原数组 -- 归并哪部分就拷贝哪部分回去
    42. 			memcpy(a+j, tmp+j, (end2-j+1)*sizeof(int));
    43. 		}
    44. 	
    45. 		printf("\n");
    46. 		gap *= 2;
    47. 	}
    48. 	free(tmp);
    49. 	tmp = NULL;
    50. }

      归并排序的特性总结：


    1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
    2. 时间复杂度：O(N*logN)
    3. 空间复杂度：O(N)
    4. 稳定性：稳定

     三、排序总结

     

     

     

     

     排序结束，C语言简单实现数据结构就告一段落了，开始进入新的阶段了！~

     

  • 相关阅读:
    OpenHarmony3.1 Release版本特性解析——硬件资源池化架构介绍
    一周总结（回溯：组合问题&切割问题）
    Docker之路（三）docker安装nginx实现对springboot项目的负载均衡
    CGM连续血糖仪方案：提供1.5V/3V研发到供应整体解决方案
    TS学习(九) :TS中的泛型
    基本算法——二分查找
    ZCMU--2195: Cableway(C语言)
    Easy-Classification-验证码识别
    mac为什么不支持ntfs，mac读取ntfs移动硬盘软件有哪些
    算法 —— 模拟
  • 原文地址：https://blog.csdn.net/m0_62824408/article/details/126807541