• DS：八大排序之堆排序、冒泡排序、快速排序

                                                     创作不易，友友们给个三连吧！！ 

    一、堆排序

    堆排序已经在博主关于堆的实现过程中详细的讲过了，大家可以直接去看，很详细,这边不介绍了

    DS：二叉树的顺序结构及堆的实现-CSDN博客

    直接上代码：

    1. void AdjustDown(int* a, int n, int parent)//升序要建大堆
    2. {
    3. 	int child = parent * 2 + 1;//假设左孩子比右孩子大
    4. 	while (child < n)
    5. 	{
    6. 	//如果假设错误，就认错
    7. 		if (child + 1 < n && a[child] < a[child + 1])
    8. 			child++;
    9. 		//如果孩子大于父亲，交换
    10. 		if (a[child] > a[parent])
    11. 		{
    12. 			Swap(&a[child], &a[parent]);
    13. 			//交换完后，让原来的孩子变成父亲，然后再去找新的孩子
    14. 			parent = child;
    15. 			child = parent * 2 + 1;
    16. 		}
    17. 		else
    18. 			break;
    19. 	}
    20. }
    21.  
    22. void HeapSort(int* a, int n)
    23. {
    24. 	//向下调整建堆
    25. 	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    26. 		AdjustDown(a, n, i);
    27. 	//大堆，向下调整
    28. 	int end = n - 1;
    29. 	while (end >= 0)
    30. 	{
    31. 		Swap(&a[0], &a[end]);
    32. 		AdjustDown(a, end, 0);
    33. 		end--;
    34. 	}
    35. }

    建堆的时间复杂度是o（N），排序的时间复杂度是（N*logN）所以堆排序的总时间复杂度是N*logN

    二、冒泡排序

    2.1 思想

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

    2.2 冒泡排序的实现

    方法：从前往后，逐一比较相邻元素，前面的大于或小于后面的则进行交换，每一轮将当前轮最大或最小的元素冒泡到当前论的最后。重复上述过程最后就是有序的。

    该排序比较简单，不画图了，不懂得可以看看博主之前写的文章有介绍：

    C语言：深入理解指针(2)-CSDN博客

    代码实现：

    1. void BubbleSort(int* a, int n)
    2. {
    3. 	for (int i = 0; i < n - 1; i++)
    4. 		//每一趟拍好一个，最后排完n-1个，最后一个数就没必要比了
    5. 	{
    6. 		for (int j = 0; j < n - i - 1; j++)//第一趟需要比较的n-1次，第二次需要比较n-2次……
    7. 			//所以结束条件跟着i变化
    8. 		{
    9. 			if (a[j] > a[j + 1])
    10. 				Swap(&a[j], &a[j + 1]);
    11. 		}
    12. 	
    13. 	}
    14. }

    2.3 冒泡排序的改进

    如果比较的过程中，比到中间的时候就有序了，但是我们并不知道，这个时候一直到后面进行的比较都是无效的，所以为了优化这个情况，我们设置一个标志，如果一趟排序中没有发生交换，说明后面都有序了，这个时候就停止冒泡排序！！

    1. void BubbleSort(int* a, int n)
    2. {
    3. 	for (int i = 0; i < n - 1; i++)
    4. 		//每一趟拍好一个，最后排完n-1个，最后一个数就没必要比了
    5. 	{
    6. 		int flag = 1;//假设有序
    7. 		for (int j = 0; j < n - i - 1; j++)//第一趟需要比较的n-1次，第二次需要比较n-2次……
    8. 			//所以结束条件跟着i变化
    9. 		{
    10. 			if (a[j] > a[j + 1])
    11. 			{
    12. 				Swap(&a[j], &a[j + 1]);
    13. 				flag = 0;//如果没有发生交换，说明不符合有序
    14. 			}
    15. 		}
    16. 		if (flag == 1)
    17. 			break;
    18. 	}
    19. }

    2.4 复杂度分析

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

    空间复杂度：O(1)

    三、快速排序

    3.1 思想

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

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

           根据区间按照基准值划分的过程，有最早的hoare版本，包括后来深入研究之后的挖坑法、前后指针法、快排法、非递归法……以下博主会用图文的方式和大家一起学习不同方法的实现！！并在这个过程中理解为什么说这中排序方法是二叉树结构。

    3.2 hoare快排实现

    hoare大佬最初的思想是：

    1、在数组中选取一个key值，一般是选择第一个元素或者最后一个元素（我们主要这边主要研究第一个元素做key值）

    2、设置两个指针，一个指针right先从往右往左找比key小的值，找到之后，另一个指针left再从左往右走找比key大的值，然后都找到后就交换两边的值，重复上述过程，最后当两个指针相遇的时候，再将相遇点的值与key点的值交换，此时key的左边都是比key小的值，key的右边都是比key大的值，这样就完成了一次选基准值的排序。

    3、完成一次找基准值的排序后，使数组有序的问题通过基准值key转化成使key左边和右边都有序的问题，也就是这个key为基准，再分割成两块区间，再分别用上述方法找各自区间的key值，继续重复之前的步骤（递归），直到区间不能被分割，此时的数组就实现了有序。

    以上的说法可能大家还不太能理解，我们通过画图来理解hoare大佬的思想。

    我们通过上图可以理解为什么说快速排序是一种二叉树结构的排序！！这个过程和二叉树的前序遍历非常相似。既然我们知道了hoare大佬具体想怎么干，我们就明白了这个快排是用递归去实现的，当然现在问题的关键就是我们如果进行基准排序去找到key值对应的位置，下面我们来分析一趟基准排序的过程

           以上就是完成一次基准排序的过程，大家会发现此时恰好key的左边是比key小的，key的右边都是比key大的，其实这并不是巧合，我们后面会分析，这边我们先实现一下一次基准排序的代码！

    基准排序代码实现：

    1. int PartSort1(int* a, int left, int right)//hoare基准排序
    2. {
    3. 	int keyi = left;
    4. 	while (left < right)
    5. 	{
    6. 	//右先找比key大的
    7. 		while (left < right&&a[right] >= a[keyi])
    8. 			right--;
    9. 	//左找比key小的
    10. 		while (left < right && a[left] <= a[keyi])
    11. 			left++;
    12. 		//找到后，就交换
    13. 		Swap(&a[left], &a[right]);
    14. 	}
    15. 	//此时相遇了，把相遇的位置和keyi的位置交换
    16. 	Swap(&a[left], &a[keyi]);
    17. 	return left;
    18. }

    根据上述的一次基准排序的实现，我们来通过递归实现整体快排的代码：

    1. void QuickSort(int* a, int left, int right)
    2. {
    3. 	if (left >= right)
    4. 		return;
    5. 	int keyi = PartSort1(a, left, right);
    6. 	//根据基准值去分割区间，继续进行基准排序
    7. 	QuickSort(a, left, keyi - 1);
    8. 	QuickSort(a, keyi+1,right);
    9. }

    思考以下问题：

    1、怎么判断递归的结束条件呢？？

    2、hoare大佬是怎么确定每次相遇的时候，相遇点的位置的值一定比key的值小呢？？

    3、left可以从第二个位置开始走吗？

    通过上述的分析，相信大家对hoare大佬的思想已经理解了！！

    3.3 挖坑法快排实现

             hoare大佬的思想真的是超凡脱俗，非常厉害，但是也有很多不容易理解的地方，后面就有人进行了改进，发明了挖坑版本的快排，虽然名字叫挖坑，但是比hoare会好理解很多，下面我们来进行挖坑版本的分析！

    发明挖坑版本大佬的思想是：

    1、先把keyi对应的值记住，然后在这个位置挖坑，right找大，找到了就停下来，将停下来的位置的值去填坑，然后right的位置变成新坑，left找小，找到后就把对应的值填坑，然后left成为新坑，以此类推下去，直到left和right相遇，将之前记住keyi的值填入坑内，这个时候就完成了一次基准排序。

    2、除了基准排序的方法和hoare大佬不同，其余地方都是一样的，也是用递归去解决。

     通过这个方法，我们来实现对应的基准排序算法

    1. int PartSort2(int* a, int left, int right)//挖坑基准排序
    2. {
    3. 	int key = a[left];//记住key的值
    4. 	int hole = left;//开始挖坑
    5. 	while (left < right)
    6. 	{
    7. 		//右先找比key大的
    8. 		while (left < right && a[right] >= key)
    9. 			right--;
    10. 		//找到后，填坑，然后挖新坑
    11. 		a[hole] = a[right];
    12. 		hole = right;
    13. 		//左找比key小的
    14. 		while (left < right && a[left] <= key)
    15. 			left++;
    16. 		//找到后，填坑，然后挖新坑
    17. 		a[hole] = a[left];
    18. 		hole = left;
    19. 	}
    20. 	//此时相遇了，把key值放在坑里
    21. 	a[hole] = key;
    22. 	return hole;
    23. }

    整体实现：

    1. void QuickSort(int* a, int left, int right)
    2. {
    3. 	if (left >= right)
    4. 		return;
    5. 	int keyi = PartSort2(a, left, right);
    6. 	//根据基准值去分割区间，继续进行基准排序
    7. 	QuickSort(a, left, keyi - 1);
    8. 	QuickSort(a, keyi+1,right);
    9. }

    我们发现挖坑和填坑的思想特别好理解！！然后接下去就是前后指针版本快排 ！！

    3.4 前后指针法快排实现

    发明前后指针版本大佬的思想是：

    1、设置前指针prev，指向首元素，后指针cur指向第二个元素，如果cur开始找小，如果没找到小，就一直往前走，如果找到小的了，就先停下来，然后prev往前走一步，在和cur交换值，然后cur接着走……重复上述步骤，最后cur走出数组返回后，循环终止！此时prev指向的位置和keyi的位置交换。

     

    下面我们来实现前后指针快排的基准排序

    1. int PartSort3(int* a, int left, int right) //前后指针基准排序
    2. {
    3. 	int prev = left;
    4. 	int cur = left + 1;
    5. 	int keyi = left;
    6. 	while (cur <= right)//cur走出数组循环停止
    7. 	{
    8. 		//cur一直在走，如果遇到比keyi小的，就停下来等perv走一步后交换，再接着走
    9. 		if (a[cur] < a[keyi])
    10. 		{
    11. 			++prev;
    12. 			Swap(&a[prev], &a[cur]);
    13. 		}
    14. 		cur++;
    15. 	}
    16. 	//cur出去后，prev的值和keyi交换
    17. 	Swap(&a[keyi], &a[prev]);
    18. 	return prev;
    19. }

     因为prev和cur指向一个位置的时候，其实没有交换的必要，所以可以将上面代码的优化一下

    1. int PartSort3(int* a, int left, int right) //前后指针基准排序
    2. {
    3. 	int prev = left;
    4. 	int cur = left + 1;
    5. 	int keyi = left;
    6. 	while (cur <= right)//cur走出数组循环停止
    7. 	{
    8. 		//cur一直在走，如果遇到比keyi小的，就停下来等perv走一步后交换，再接着走
    9. 		if (a[cur] < a[keyi]&&++prev!=cur)
    10. 			Swap(&a[prev], &a[cur]);
    11. 		cur++;
    12. 	}
    13. 	//cur出去后，prev的值和keyi交换
    14. 	Swap(&a[keyi], &a[prev]);
    15. 	return prev;
    16. }

    整体快排的实现：

    1. void QuickSort(int* a, int left, int right)
    2. {
    3. 	if (left >= right)
    4. 		return;
    5. 	int keyi = PartSort3(a, left, right);
    6. 	//根据基准值去分割区间，继续进行基准排序
    7. 	QuickSort(a, left, keyi - 1);
    8. 	QuickSort(a, keyi+1,right);
    9. }

    3.5 快排的复杂度分析

    时间复杂度：O(logN*N)

     如果使用了三数取中的优化方法（后面会介绍），那么快排就不可能出现O（N^2）的情况，所以最后时间复杂度是O(logN*N)

    空间复杂度：O(logN)

             因为递归是要开销栈帧的，空间可以重复利用而时间不可重复利用。所以这里至多递归到他的深度即h = logN,所以他的空间复杂度是O(logN)

    3.6 快排的优化

    快排优化的过程源于这道OJ题

    力扣：排序数组

    看到这题，你可能会很开心：这不就是一个排序吗？我把最厉害的快排用上肯定能过的！！

    结果是这样的——

    为什么呢？？因为力扣的测试用例设置了一个有序的数组来针对快排（复杂度分析过原因了），本质上就是因为有序的时候前面的keyi太小了！！所以我们设置一个改进方法——三数取中，解决有序的情况

    3.6.1 三数取中——针对有序

    1. int GetMidIndex(int* a, int left, int right)
    2. {
    3. 	int mid = (left + right) / 2;
    4. 	if (a[left] < a[mid])
    5. 	{
    6. 		if (a[mid] < a[right])
    7. 			return mid;
    8. 		else if (a[right] < a[left])
    9. 			return left;
    10. 		else
    11. 			return right;
    12. 	}
    13. 	else//a[left] >a[mid]
    14. 	{
    15. 		if (a[mid] > a[right])
    16. 			return mid;
    17. 		else if (a[right] > a[left])
    18. 			return left;
    19. 		else
    20. 			return right;
    21. 	}
    22. }

    封装后，我们前面三种方法的基准值排序都要加上以下代码，这样就可以确保keyi的值是中间值了

    1. int mid = GetMidIndex(a, left, right);
    2. Swap(&a[mid], &a[left]);

    你可能觉得这样子应该能过了 ，那我们再测试一下——

    结果你发现，又被针对了，有序的情况解决了，又面临着有大量重复数据的排序问题，我们来分析一下：

    你会发现，重复其实跟有序的情况是一样的，每次right指针都会走到keyi的位置，这样子时间复杂度也变成O（N^2）了。所以为了解决重复的问题，我们有了三路划分的方法—— 

    3.6.2 三路划分——针对重复

    因为每次递归需要返回两个边界才行，所以没办法单独封装一个partsort函数 

    代码实现： 

    1. void QuickSort2(int* a, int left, int right)
    2. {
    3. 	if (left >= right)
    4. 		return;
    5. 	int mid = GetMidIndex(a, left, right);
    6. 	Swap(&a[mid], &a[left]);
    7. 	int phead = left;
    8. 	int pcur = left + 1;
    9. 	int ptail = right;
    10. 	int key = a[left];
    11. 	while (pcur <= ptail)
    12. 	{
    13. 		if (a[pcur] < key)
    14. 		{
    15. 			Swap(&a[pcur], &a[phead]);
    16. 			pcur++;
    17. 			phead++;
    18. 		}
    19. 		else if (a[pcur] > key)
    20. 		{
    21. 			Swap(&a[pcur], &a[ptail]);
    22. 			ptail--;
    23. 		}
    24. 		else
    25. 			pcur++;
    26. 	}
    27. 	QuickSort2(a, left, phead - 1);
    28. 	QuickSort2(a, ptail+1,right);
    29. }

    结果我们发现，还是过不了，那究竟是哪里出问题了呢？？ 

    因为里面有一组测试用例针对了三数取中，也就是他把偏大和偏小的数都安排在恰好的位置，所以我们为了针对这种情况，将三数取中的其中一个数改成随机数，接下来我们对三数取中再优化

    3.6.3 三数取中再优化

    将三数取中的其中一个数的下标变成随机下标：

    同时要记得在主函数加上时间种子

    1. int GetMidIndex2(int* a, int left, int right)
    2. {
    3. 	int mid = left + (rand() % (right - left));
    4. 	if (a[left] < a[mid])
    5. 	{
    6. 		if (a[mid] < a[right])
    7. 			return mid;
    8. 		else if (a[right] < a[left])
    9. 			return left;
    10. 		else
    11. 			return right;
    12. 	}
    13. 	else//a[left] >a[mid]
    14. 	{
    15. 		if (a[mid] > a[right])
    16. 			return mid;
    17. 		else if (a[right] > a[left])
    18. 			return left;
    19. 		else
    20. 			return right;
    21. 	}
    22. }
    1. void QuickSort2(int* a, int left, int right)
    2. {
    3. 	if (left >= right)
    4. 		return;
    5. 	int mid = GetMidIndex2(a, left, right);
    6. 	Swap(&a[mid], &a[left]);
    7. 	int phead = left;
    8. 	int pcur = left + 1;
    9. 	int ptail = right;
    10. 	int key = a[left];
    11. 	while (pcur <= ptail)
    12. 	{
    13. 		if (a[pcur] < key)
    14. 		{
    15. 			Swap(&a[pcur], &a[phead]);
    16. 			pcur++;
    17. 			phead++;
    18. 		}
    19. 		else if (a[pcur] > key)
    20. 		{
    21. 			Swap(&a[pcur], &a[ptail]);
    22. 			ptail--;
    23. 		}
    24. 		else
    25. 			pcur++;
    26. 	}
    27. 	QuickSort2(a, left, phead - 1);
    28. 	QuickSort2(a, ptail+1,right);
    29. }

    终于过了！！要重点理解快排的优化思想！！ 

    3.7 非递归法快排实现

    3.7.1 栈实现

    我们发现无论是hoare、挖坑还是前后指针，本质区别就是基准排序方法不同，但最后还是用递归去解决的，递归虽好但是有些时候如果数据太大的话还是有可能造成栈空间不够的情况，因此我们应该研究一下如果非递归实现！！——利用栈！

    利用栈实现非递归快排的大佬的思想是：

    利用栈来存储基准排序需要处理的区间，每次从栈拿出需要处理的区间，再将分割的区间放进栈中，利用栈后进先出的特点，每次都会先处理左边的区间再处理右边的区间，模拟了递归的过程。

    我们画个图来理解吧！！（类似二叉树的前序遍历）

     非递归快排代码实现：

    需要包含栈的相关代码

    1. void QuickSortNonR1(int* a, int left, int right)
    2. {
    3. 	Stack st;
    4. 	StackInit(&st);
    5. 	//把区间压进去,一定要先压右区间！！
    6. 	StackPush(&st, right);
    7. 	StackPush(&st, left);
    8. 	while (!StackEmpty(&st))
    9. 	{
    10. 		//将数据弹出来进行进准计算
    11. 		int left = StackTop(&st);
    12. 		StackPop(&st);
    13. 		int right= StackTop(&st);
    14. 		StackPop(&st);
    15. 		//进行基准计算
    16. 		int keyi = PartSort3(a, left, right);
    17. 	    //分割区间（left keyi-1）keyi（keyi+1，right）
    18. 		//如果对应的区间还能分割，就继续压,要注意要先压后面在压前面
    19. 		if (keyi + 1 < right)
    20. 		{
    21. 			StackPush(&st, right);
    22. 			StackPush(&st, keyi+1);
    23. 		}
    24. 		if (keyi - 1 > left)
    25. 		{
    26. 			StackPush(&st, keyi-1);
    27. 			StackPush(&st,left);
    28. 		}
    29. 	}
    30. 	//会一直到栈为空，此时就拍好序了！！
    31. 	StackDestory(&st);
    32. }

    3.7.2 队列实现

    使用队列也是可以的！！就有点类似二叉树的层序遍历！

    代码实现：

     需要包含队列的一些文件

    1. void QuickSortNonR2(int* a, int left, int right)
    2. {
    3. 	Queue q;
    4. 	QueueInit(&q);
    5. 	QueuePush(&q, left);
    6. 	QueuePush(&q, right);
    7. 	while (!QueueEmpty(&q))
    8. 	{
    9. 		int left = QueueFront(&q);
    10. 		QueuePop(&q);
    11. 		int right = QueueFront(&q);
    12. 		QueuePop(&q);
    13. 		int keyi = PartSort3(a, left, right);
    14. 		if (keyi - 1 > left)
    15. 		{
    16. 			QueuePush(&q, left);
    17. 			QueuePush(&q, keyi-1);
    18. 		}
    19. 		if (keyi + 1 
    20. 		{
    21. 			QueuePush(&q, keyi +1);
    22. 			QueuePush(&q, right);
    23. 		}
    24. 	}
    25. 	QueueDestory(&q);
    26. }

     

  • 相关阅读:
    php项目加密源码
    以TrueType为例谈字形描述
    c#设计模式-行为型模式 之 责任链模式
    微信支付-无法重写WXPayConfig内的部分抽象方法
    Springboot流浪狗领养管理系统毕业设计源码260839
    Angular 使用教程——基本语法和双向数据绑定
    windows安装yarn 详细教程
    线程池工作流程-图示
    智能制造云办公 v3.7.25 发布，微服务拆分
    什么时候用@MapperScan 注解？
  • 原文地址：https://blog.csdn.net/weixin_51142926/article/details/136122804