[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) -- 缺点
    • 稳定性：稳定
相关推荐
tinker在coding17 分钟前
Coding Caprice - Linked-List 1
算法·leetcode
XH华5 小时前
初识C语言之二维数组(下)
c语言·算法
南宫生5 小时前
力扣-图论-17【算法学习day.67】
java·学习·算法·leetcode·图论
不想当程序猿_5 小时前
【蓝桥杯每日一题】求和——前缀和
算法·前缀和·蓝桥杯
落魄君子5 小时前
GA-BP分类-遗传算法（Genetic Algorithm）和反向传播算法（Backpropagation）
算法·分类·数据挖掘
菜鸡中的奋斗鸡→挣扎鸡6 小时前
滑动窗口 + 算法复习
数据结构·算法
Lenyiin6 小时前
第146场双周赛：统计符合条件长度为3的子数组数目、统计异或值为给定值的路径数目、判断网格图能否被切割成块、唯一中间众数子序列 Ⅰ
c++·算法·leetcode·周赛·lenyiin
郭wes代码6 小时前
Cmd命令大全（万字详细版）
python·算法·小程序
scan7246 小时前
LILAC采样算法
人工智能·算法·机器学习
菌菌的快乐生活6 小时前
理解支持向量机
算法·机器学习·支持向量机
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程