[C][数据结构][排序][下][快速排序][归并排序]详细讲解

DieSnowK2024-06-14 18:43

文章目录

1.快速排序

1.基本思想

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

2.hoare版本

  • 选key -- 一般是最左边或者最右边的值

    • 左作key，让右边先走
    • 右作key，让左边先走

  • 为什么左边做key，要让右边先走?

    • 要保证相遇位置的值，比key小/就是key
      • R先走，R停下，L去遇到R
        • 相遇位置就是R停下来的位置，必定比key小
      • R先走，R没有找到比key小的值，R去遇到了L
        • 相遇位置就是L上一轮停下来的位置，比key小/就是key

  • left向前找大

  • right向后找小

  • 单趟排完以后：

    • 左边都比key小
    • 右边都比key大

  • 实现：

    cpp 复制代码 
    void QuickSort1(int* a, int begin, int end)
{
	//结束条件  --  只有一个数 --> begin == end || 区间不存在 --> begin > end
	if (begin >= end)
	{
		return;
	}
 
	if (end - begin > 0)
	{
		//hoare版本
		int left = begin, right = end;
		int keyi = left;
 
		while (left < right)
		{
			//右边先走，找小
			while (left < right && a[right] >= a[keyi])  //left < right是为了防止越界
			{
				right--;
			}
 
			//左边再走，找大
			while (left < right && a[left] <= a[keyi])
			{
				left++;
			}
 
			//交换
			Swap(&a[left], &a[right]);
		}
 
		Swap(&a[keyi], &a[left]);
		keyi = left;
 
		//key已经正确的位置上，左边都比key小，右边都比key大
		//递归，分治 --  [begin,keyi - 1]  keyi  [keyi + 1,end]
		QuickSort1(a, begin, keyi - 1);
		QuickSort1(a, keyi + 1, end);
	}
	else
	{
		//直接插入排序
		InsertSort(a + begin, end - begin + 1);
	}
}

3.挖坑法

  • 本质同hoare，但是好理解些

  • 右边找小，填到左边的坑里去，这个位置形成新的坑

  • 左边找大，填到右边的坑里去，这个位置形成新的坑

  • 实现：

    cpp 复制代码 
    void QuickSort2(int* a, int begin, int end)
{
	//结束条件  --  只有一个数 --> begin == end || 区间不存在 --> begin > end
	if (begin >= end)
	{
		return;
	}
 
	if (end - begin > 0)
	{
		//挖坑法
		int key = a[begin];
		int piti = begin;
		int left = begin, right = end;
 
		while (begin < end)
		{
			//右边找小，填到左边的坑里去，这个位置形成新的坑
			while (begin < end && a[right] >= key)
			{
				right--;
			}
 
			a[piti] = a[right];
			piti = right;
 
			//左边找大，填到右边的坑里去，这个位置形成新的坑
			while (begin < end && a[left] <= key)
			{
				left++;
			}
 
			a[piti] = a[left];
			piti = left;
		}
 
		a[piti] = key;
 
		//key已经正确的位置上，左边都比key小，右边都比key大
		//递归，分治 --  [begin,keyi - 1]  keyi  [keyi + 1,end]
		QuickSort2(a, begin, piti - 1);
		QuickSort2(a, piti + 1, end);
	}
	else
	{
		//直接插入排序
		InsertSort(a + begin, end - begin + 1);
	}
}

4.前后指针版本

  • cur向前找小，遇到小，则prev++，且交换cur、prev

  • 实现：

    cpp 复制代码 
    void QuickSort3(int* a, int begin, int end)
{
	//结束条件  --  只有一个数 --> begin == end || 区间不存在 --> begin > end
	if (begin >= end)
	{
		return;
	}
 
	if (end - begin > 0)
	{
		//前后指针版本
		int prev = begin;
		int cur = begin + 1;
		int keyi = begin;
 
		//加入三数取中的优化
		int midi = GetMidIndex(a, begin, end);
		Swap(&a[keyi], &a[midi]);
 
		while (cur <= end)  //一直往后走，遇到小则停下来处理
		{
			//cur找小
			if (a[cur] < a[keyi] && ++prev != cur)  //防止prev和cur重合时，重复交换
			{
				Swap(&a[prev], &a[cur]);
			}
 
			cur++;
		}
 
		Swap(&a[keyi], &a[prev]);
		keyi = prev;
 
		//key已经正确的位置上，左边都比key小，右边都比key大
		//递归，分治 --  [begin,keyi - 1]  keyi  [keyi + 1,end]
		QuickSort3(a, begin, keyi - 1);
		QuickSort3(a, keyi + 1, end);
	}
	else
	{
		//直接插入排序
		InsertSort(a + begin, end - begin + 1);
	}
}

5.非递归版本改写

  • 为何需要改写非递归?

    • 极端场景下，若深度太深，会出现栈溢出

  • 方法：用数据结构栈模拟递归过程

  • 实现：

    cpp 复制代码 
    //用栈模拟递归 -- 先进后出
void QuickSortNonR(int* a, int begin, int end)
{
	Stack st;
	StackInit(&st);
	
	StackPush(&st, end);
	StackPush(&st, begin);
 
	while (!isStackEmpty(&st))
	{
		//从栈中取出两个数，作为区间
		int left = StackTop(&st);
		StackPop(&st);
		int right = StackTop(&st);
		StackPop(&st);
 
		//排序，取keyi
		int keyi = PartSort3(a, left, right);
 
		//此时分成了两个区间 [left, keyi-1] keyi [keyi+1, right]
		//继续压栈
		if (keyi + 1 < right)
		{
			StackPush(&st, right);
			StackPush(&st, keyi + 1);
		}
 
		if (left < keyi - 1)
		{
			StackPush(&st, keyi - 1);
			StackPush(&st, left);
		}
	}
 
	StackDestroy(&st);
}

  • 特性总结：

    • 综合性能&使用场景比较好
    • 时间复杂度:O(N*logN)
    • 空间复杂度:O(logN)
    • 稳定性：不稳定

  • [快速排序]优化方案

    • 三数取中法选key
      • 防止key都是极端数字 --> 递归过深 --> 栈溢出
    • 递归到小的子区间时，考虑使用插入排序
      • 大幅减少递归次数，提高效率
      • 例：最后一层递归占了总递归次数的50%，但可能只有极少量的数

2.归并排序

  • 基本思想：

  • 分治思维

    • 将已有序的子序列合并，得到完全有序的序列
    • 即先使每个子序列有序，再使子序列段间有序。
    • 若将两个有序表合并成一个有序表，称为二路归并

  • 归并排序核心步骤：

  • 实现：

    cpp 复制代码 
    //函数名前加_表示这个函数是内部函数，不对外提供接口 - 子函数
//后序思想
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
	{
		return;
	}
 
	int mid = (begin + end) / 2;
 
	//[begin, mid] [mid+1, end] 分治递归，让子区间有序
	_MergeSort(a,begin,mid,tmp);
	_MergeSort(a,mid+1,end,tmp);
 
	//归并 [begin, mid] [mid+1, end]
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin1;
	while (begin1 <= end1 && begin2 <= end2)  //有一组结束则结束
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
 
	//已经有一组结束了，拷贝另一组剩余的
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
 
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
 
	//把归并数据拷贝回原数组
	memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
 
//时间复杂度:O(N*logN)
//空间复杂度:O(N)
void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("MergeSort");
		exit(-1);
	}
 
	_MergeSort(a, 0, n - 1, tmp);
 
	free(tmp);
}

  • 非递归版本改写

  • 实现：

  • ①

    cpp 复制代码 
    void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc:");
		exit(-1);
	}
 
	//手动归并
	int gap = 1;  //每次归并的元素个数
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			//[i, i+gap-1] [i+gap,i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
 
			//越界处理 - 修正边界
			if (end1 >= n)
			{
				end1 = n - 1;
				//[begin2, end2]修正为不存在区间
				begin2 = n;
				end2 = n - 1;
			}
			else if (begin2 >= n)
			{
				// [begin2, end2]修正为不存在区间
				begin2 = n;
				end2 = n - 1;
			}
			else if (end2 >= n)
			{
				end2 = n - 1;
			}
 
 
			//归并
			int j = begin1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}
 
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
 
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
 
		}
 
		//全部归并完后，拷贝回原数组
		memcpy(a, tmp, sizeof(int) * n);
 
		gap *= 2;
	}
 
	free(tmp);
}

  • ②

    cpp 复制代码 
    void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc:");
		exit(-1);
	}
 
	//手动归并
	int gap = 1;  //每次归并的元素个数
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			//[i, i+gap-1] [i+gap,i+2*gap-1]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
 
			//越界处理
			//end1越界或者begin2越界，则可以不归并了
			if (end1 >= n || begin2 >= n)
			{
				break;
			}
			else if (end2 >= n)
			{
				end2 = n - 1;
			}
 
			//归并
			int m = end2 - begin1 + 1;
			int j = begin1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}
 
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
 
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
 
			memcpy(a + i, tmp + i, sizeof(int) * m);
		}
 
		gap *= 2;
	}
 
	free(tmp);
}

  • 特性总结：

    • 更多解决在磁盘中的外排序问题
    • 时间复杂度:O(N*logN)
    • 空间复杂度:O(N) -- 缺点
    • 稳定性：稳定
相关推荐
当年拼却醉颜红6 分钟前
力扣爆刷第161天之TOP100五连刷71-75（搜索二叉树、二维矩阵、路径总和）
算法·leetcode·矩阵
cjay_fighting18 分钟前
Sentinel
算法·sentinel
yava_free33 分钟前
详解Java垃圾回收（GC）机制
java·jvm·算法
wlwhonest1 小时前
最短路算法——差分约束
算法
中草药z1 小时前
【Java算法】二分查找 上
数据结构·笔记·算法·leetcode·二分查找·学习方法
努力学习的小廉1 小时前
双向链表 -- 详细理解和实现
数据结构·链表
破晓的历程1 小时前
【机器学习】机器学习的重要方法——线性回归算法深度探索与未来展望
算法·机器学习·线性回归
c沫栀1 小时前
C - Sierpinski carpet（abc357）
c语言·c++·算法
Miracle_86.2 小时前
【数据结构】单链表：数据结构中的舞者，穿梭于理论与实践的舞池
c语言·数据结构·链表·学习方法
SpongeG2 小时前
C++期末综合练习
开发语言·c++·算法
热门推荐
012024年江苏省研究生数学建模科研创新实践大赛C题气象数据高精度融合技术研究论文和代码分析02Coze扣子平台完整体验和实践（附国内和国际版对比）03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）05【经验分享】Ubuntu22.04安装微信(linux官方版)06【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解072024亚太赛（中文赛）数学建模竞赛选题建议+初步分析082025张宇考研数学，百度网盘视频课+36讲PDF讲义+真题09通达信神奇九转指标原理及选股公式，无未来函数，数字不消失102024 年第十四届 APMCM 亚太地区大学生数学建模竞赛B题超详细解题思路+数据预处理问题一代码分享