排序八卦炉之冒泡、快排【完整版】

已于 2023-08-07 17:28:24 修改
阅读量192 收藏
点赞数 1
分类专栏： 深度学习数据结构 文章标签： c语言 数据结构 排序算法 算法
于 2023-08-04 20:50:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHRan_ran_/article/details/132112021
版权

文章目录

在这里插入图片描述

1.冒泡排序

在这里插入图片描述

1.1代码实现

//插入排序  O(N)~O(N^2)
//冒泡排序  O(N)~O(N^2)
//当数据有序 二者均为O(N)
//当数据接近有序或局部有序 插排更优
void BubbleSort(int* a, int n)
{
	assert(a);
	int flag = 1;
	for (int i = 0; flag && i < n - 1; ++i)
	{
		flag = 0;
		for (int j = 0; j < n - 1 - i; ++j)
		{
			if (a[j] > a[j + 1])
			{
				Swap(&a[j + 1], &a[j]);
				flag = 1;
			}
		}
	}
}

1.2复杂度

  1. 最坏：
    比较n-1轮
    每一轮比较次数：n n-1 n-2 n-3 … 1 ≈ N^2
  2. 最优：
    比较n-1轮
    数据有序–每一轮只判断不比较 – N

2.快速排序

2.1人物及思想介绍【源于百度】

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

2.2hoare【霍尔】版本

1.初识代码

//霍尔版本
int PartSort1(int* a, int begin, int end)
{

	int left = begin, right = end, x = left;
	while (left < right)
	{
		//右找小
		while (left < right && a[right] >= a[x])
			--right;

		//左找大
		while (left < right && a[left] <= a[x])
			++left;

		Swap(&a[left], &a[right]);
	}

	Swap(&a[x], &a[left]);
	x = left;

	return x;
}
void QuickSort(int* a, int begin, int end)    
{
	//begin：左区间左边界下标 
	//end  ：右区间右边界下标
	//begin==end:数据量=1 无需排序 直接返回
	//begin>end :无效区间 无需排序 直接返回
	if (begin >= end)
		return;

	int x = PartSort1(a, begin, end);

	// [begin, x - 1] x [x + 1, end]
	QuickSort(a, begin, x - 1);
	QuickSort(a, x+1, end);
}

2.代码分析

在这里插入图片描述

3.思其因果

Q：为什么a[x]【作为基准值key】置于左侧 – 右边先移动？
A：目的是为了保证相遇位置的值<=key 从而把key与相遇值交换 不打乱“左放小，右放大”的思想
在这里插入图片描述

2.3挖坑版本

1.初始代码

//挖坑版本
int PartSort2(int* a, int begin, int end)
{
	int x = begin, key = a[begin];

    while (begin < end)
	{
		while (begin < end && a[end] >= key)
			--end;
		a[x] = a[end];
		x = end;


		while (begin < end && a[begin] <= key)
			++begin;
		a[x] = a[begin];
		x = begin;
	}

	a[x] = key;
	return x;
}
void QuickSort(int* a, int begin, int end)    
{
	//begin：左区间左边界下标 
	//end  ：右区间右边界下标
	//begin==end:数据量=1 无需排序 直接返回
	//begin>end :无效区间 无需排序 直接返回
	if (begin >= end)
		return;

	int x = PartSort1(a, begin, end);

	// [begin, x - 1] x [x + 1, end]
	QuickSort(a, begin, x - 1);
	QuickSort(a, x+1, end);
}

2.代码分析

在这里插入图片描述

3.思想比较

霍尔版本：右找小 左找打 大小交换 依次递归
挖坑版本：记录key值 x位–置空 右找小入坑 坑位更新 左找大入坑 坑位更新 依次递归

在这里插入图片描述

2.4指针版本

1.初识代码

int PartSort3(int* a, int begin, int end)
{   //prv：previous  cp：current pointer
	
	int prv = begin, cp = begin + 1, x = begin;

	while (cp <= end)
	{
		if (a[cp] < a[x] && ++prv != cp)
			Swap(&a[prv], &a[cp]);

		++cp;
	}
	Swap(&a[prv], &a[x]);
	x = prv;
	
	return x;
}
void QuickSort(int* a, int begin, int end)    
{
	//begin：左区间左边界下标 
	//end  ：右区间右边界下标
	//begin==end:数据量=1 无需排序 直接返回
	//begin>end :无效区间 无需排序 直接返回
	if (begin >= end)
		return;

	int x = PartSort3(a, begin, end);

	// [begin, x - 1] x [x + 1, end]
	QuickSort(a, begin, x - 1);
	QuickSort(a, x+1, end);
}

2.代码分析

在这里插入图片描述

3.问题探讨

在这里插入图片描述

2.5集体优化

//快速排序   O(N * logN)
//对任意区间三值取中位数
int GetMid_X(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;

	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] < a[end])
			return end;
		else
			return begin;
	}
	else //a[begin] >= a[mid]
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}
//霍尔版本
int PartSort1(int* a, int begin, int end)
{
	int left = begin, right = end, x = left;

	//确定更合适的key
	int mid_x = GetMid_X(a, begin, end);
	Swap(&a[x], &a[mid_x]);

	while (left < right)
	{
		//右找小
		while (left < right && a[right] >= a[x])
			--right;

		//左找大
		while (left < right && a[left] <= a[x])
			++left;

		Swap(&a[left], &a[right]);
	}

	Swap(&a[x], &a[left]);
	x = left;

	return x;
}
//挖坑版本
int PartSort2(int* a, int begin, int end)
{
	int x = begin;
	
	//确定更合适的key
	int mid_x = GetMid_X(a, begin, end);
	Swap(&a[x], &a[mid_x]); 
	int key = a[x];
    
	while (begin < end)
	{
		while (begin < end && a[end] >= key)
			--end;
		a[x] = a[end];
		x = end;


		while (begin < end && a[begin] <= key)
			++begin;
		a[x] = a[begin];
		x = begin;
	}

	a[x] = key;
	return x;
}  
//指针版本
int PartSort3(int* a, int begin, int end)
{   //prv：previous  cp：current pointer
	
	int prv = begin, cp = begin + 1, x = begin;
	
	//确定更合适的key
	int mid_x = GetMid_X(a, begin, end);
	Swap(&a[x], &a[mid_x]);

	while (cp <= end)
	{
		if (a[cp] < a[x] && ++prv != cp)
			Swap(&a[prv], &a[cp]);

		++cp;
	}
	Swap(&a[prv], &a[x]);
	x = prv;
	
	return x;
}
void QuickSort(int* a, int begin, int end)    
{
	//begin：左区间左边界下标 
	//end  ：右区间右边界下标
	//begin==end:数据量=1 无需排序 直接返回
	//begin>end :无效区间 无需排序 直接返回
	if (begin >= end)
		return;

	int x = PartSort2(a, begin, end);

	// [begin, x - 1] x [x + 1, end]
	QuickSort(a, begin, x - 1);
	QuickSort(a, x+1, end);
}

2.6极致优化

在这里插入图片描述

在这里插入图片描述

2.7非递归版本

递归版本存在的问题：若递归层次太深 导致栈溢出问题
递归改非递归的方法：

  1. 直接改循环 – 斐波那契数列、归并排序等
  2. 数据结构的栈（Stack）模拟递归【Stack的空间是从堆申请的 堆内存比栈内存大】

1.初识代码

int PartSort3(int* a, int begin, int end)
{   //prv：previous  cp：current pointer
	int prv = begin, cp = begin + 1, x = begin;
	//确定更合适的key
	int mid_x = GetMid_X(a, begin, end);
	Swap(&a[x], &a[mid_x]);
	while (cp <= end)
	{
		if (a[cp] < a[x] && ++prv != cp)
			Swap(&a[prv], &a[cp]);
		++cp;
	}
	Swap(&a[prv], &a[x]);
	x = prv;
	return x;
}
void QuickSort_NonRecursion(int* a, int begin, int end)
{
	ST st;
	StackInit(&st);

	StackPush(&st, begin);
	StackPush(&st, end);

	while (!StackEmpty(&st))
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);

		int x = PartSort3(a, left, right);
		 
		if (x + 1 < right)
		{
			StackPush(&st, x + 1);
			StackPush(&st, right);
		}
		// [left, x-1] x [x+1, right]
		if (left < x - 1)
		{
			StackPush(&st, left);
			StackPush(&st, x - 1);
		}
	}
	StackDestroy(&st);
}

2.代码分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.8相关博客及完整代码

点击 [qsort与bubble之间不为人知的关系](htt p://t.csdn.cn/filuW) 查看博主之前关于分析这两个排序的博客。

//快速排序   O(N * logN)
int count = 0;  //测试递归次数
//对任意区间三值取中位数
int GetMid_X(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;

	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] < a[end])
			return end;
		else
			return begin;
	}
	else //a[begin] >= a[mid]
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}
//霍尔版本
int PartSort1(int* a, int begin, int end)
{
	int left = begin, right = end, x = left;

	//确定更合适的key
	int mid_x = GetMid_X(a, begin, end);
	Swap(&a[x], &a[mid_x]);

	while (left < right)
	{
		//右找小
		while (left < right && a[right] >= a[x])
			--right;

		//左找大
		while (left < right && a[left] <= a[x])
			++left;

		Swap(&a[left], &a[right]);
	}

	Swap(&a[x], &a[left]);
	x = left;

	return x;
}
//挖坑版本
int PartSort2(int* a, int begin, int end)
{
	int x = begin;
	
	//确定更合适的key
	int mid_x = GetMid_X(a, begin, end);
	Swap(&a[x], &a[mid_x]); 
	int key = a[x];
    
	while (begin < end)
	{
		while (begin < end && a[end] >= key)
			--end;
		a[x] = a[end];
		x = end;


		while (begin < end && a[begin] <= key)
			++begin;
		a[x] = a[begin];
		x = begin;
	}

	a[x] = key;
	return x;
}  
//指针版本
int PartSort3(int* a, int begin, int end)
{   //prv：previous  cp：current pointer
	int prv = begin, cp = begin + 1, x = begin;
	//确定更合适的key
	int mid_x = GetMid_X(a, begin, end);
	Swap(&a[x], &a[mid_x]);
	while (cp <= end)
	{
		if (a[cp] < a[x] && ++prv != cp)
			Swap(&a[prv], &a[cp]);
		++cp;
	}
	Swap(&a[prv], &a[x]);
	x = prv;
	return x;
}

void QuickSort(int* a, int begin, int end)
{
	count++;
	//begin：左区间左边界下标 
	//end  ：右区间右边界下标
	//begin==end:数据量=1 无需排序 直接返回
	//begin>end :无效区间 无需排序 直接返回
	if (begin >= end)
		return;

	int x = PartSort3(a, begin, end);

	// [begin, x - 1] x [x + 1, end]
	QuickSort(a, begin, x - 1);
	QuickSort(a, x+1, end);
}

/*
void QuickSort(int* a, int begin, int end)
{
	count++;
	if (begin >= end)
		return;
	
	if (end - begin > 10)
	{
		int x = PartSort3(a, begin, end);
		
		// [begin, x-1] x [x+1, end]
		QuickSort(a, begin, x - 1);
		QuickSort(a, x + 1, end);
	}
	else 
		InsertSort(a + begin, end - begin + 1);
}
*/
//非递归版本
void QuickSort_NonRecursion(int* a, int begin, int end)
{
	ST st;
	StackInit(&st);

	StackPush(&st, begin);
	StackPush(&st, end);

	while (!StackEmpty(&st))
	{
		int end = StackTop(&st);
		StackPop(&st);
		int begin = StackTop(&st);
		StackPop(&st);

		int x = PartSort3(a, begin, end);
		 
		if (x + 1 < end)
		{
			StackPush(&st, x + 1);
			StackPush(&st, end);
		}
		// [begin, x-1] x [x+1, end]
		if (begin < x - 1)
		{
			StackPush(&st, begin);
			StackPush(&st, x - 1);
		}
	}
	StackDestroy(&st);
}
阿猿收手吧！
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ミニ八卦炉 ver.2.0.zip
03-10
带变型动作的，可变型八卦炉，东方MMD魔理沙的装B道具，内含使用教程、动作vmd、模型pmx等，需要的拿去做MMD
中国科学家建立可与人脑突触数量相较的AI模型——“八卦炉”
人工智能学家
06-28 645
来源：俄罗斯卫星通讯社中国科学家基于最新的一台配备双威处理器的超级计算机，建立了“脑级人工智能模型”——八卦炉（BAGUALU）。其具有174万亿个参数，可与人脑中的突触数量相媲美，将在从自动驾驶汽车到科学研究的各种场景中应用。AI大模型(Foundation Models):是指经过大规模数据训练且在经微调后即可适应广泛下游任务的模型。随着参数规模不断扩大，AI大模型在...
[转载]物理大神的八卦完整版——大爱物理
热门推荐
weixin_34151004的博客
04-08 1万+
这套八卦最早是四年前在熊博网的留言那里看到的，当然那个留言也是转载。后来可能是因为《生活大爆炸》热播的原因，很多高校论坛都有转载，刚刚搜了一下还是这个最全。豆瓣上也有整理版但只是很少的一部分，可惜找不到原始搜集作者是谁了。 BTW：当年牛逼的熊博网都被封了快三年了，08年那个春夏之交后就再也不能更新和查看，还真是时光如梭啊。至今都不知道singularitys究竟是谁，那是俺唯一膜拜过的现实存在...
太上老君的炼丹炉之分布式 Quorum NWR
悟空聊架构的专栏
03-04 2265
太白金星：听闻老君最近在练神丹妙药，可否与我一讲？ 太上老君：老白啊，我最近在练六颗丹药：两颗延年丹、两颗健步丹、两颗恢复丹。 太白金星：那这三个八卦炉定是练这三件法宝的了？ 太上老君：正是正是。而且对于相同的丹药，功效和大小还得完全一样。 一、三个炼丹炉怎么分配的 太白金星：老君，你的八卦炉怎么分配的啊？ 让我们揭开老君的炼丹炉，看看六颗丹药是怎么分配的。 首先我们是很容易猜到丹炉是怎么分配炼丹的： 一号丹炉炼两颗延年丹。 二号丹炉炼两颗健步丹。 三号丹炉炼两颗恢复丹。 那如此分配会有什么.
计算机中的八卦知识,论八卦与电脑的关系
weixin_39996496的博客
06-28 1584
一直想写这篇文章，但苦于对自己所了解的知识实在不敢过于自信，所以一直没有起笔。很多人认为八卦这东西就是典型的迷信，什么两仪四象八卦，乾艮巽这些东西全是伪科学，没有任何科学依据，那么今天我就通过这篇文章来和大家一起探讨一下我们认为科技最顶端的计算机与我们认为迷信的八卦到底有着怎么样的微妙关系。计算机原理(算盘与十进制)计算机原理也称微机原理，是现在职高学生必修的一门课程，我们当年为了应付考试只学了半...
程序猿修仙之路--算法之直接插入排序
架构师修行之路
04-12 1304
算法主要衡量标准 时间复杂度（运行时间） 在算法时间复杂度维度，我们主要对比较和交换的次数做对比，其他不交换元素的算法，主要会以访问数组的次数的维度做对比。 其实有很多同学对于算法的时间复杂度有点模糊，分不清什么所谓的 O(n),O(nlogn),O(logn)…等，也许下图对一些人有一些更直观的认识。 空间复杂度（额外的内存使用） 排序算法的额外内存开销和运行时间同等...
完整版易2.55版数据库记录编辑器模块.rar
04-02
完整版易2.55版数据库记录编辑器模块.rar
jQuery八卦图背景时钟代码
06-24
jQuery八卦图背景时钟代码是一款具有中国风的特色的时间结合八卦图算风水时钟代码。
八卦时钟源代码.rar
04-03
超酷的八卦时钟源代码
AtCoder Beginner Contest 354 C - AtCoder Magics
2302_79545206的博客
05-19 768
因此我们对所有的卡片进行按照cost从小到大排序，v表示前i-1张卡片中最强的力量，如果第i张卡片力量大于等于v，说明这种卡片可以保留。反之，如果第i张卡片比i弱，又因为它还贵,那么我们就不要这张卡片了。首先，要明白这道题要我们做什么，就是丢弃这些卡片，然后输出剩余卡片的编号，那么什么样的卡片要舍弃呢？如果这个卡片它又贵还又弱，那么我们就不要它。自己加一些感悟，用朴素的语言来解释这道题目。首先声明本篇博客代码取自。
嵌入式0基础开始学习 Ⅱ 数据结构（1）数据结构
最新发布
qq_63137715的博客
05-23 144
在计算机科学中是指所有能入到计算机中并被计算机程序处理的符号的总称。是性质相同的数据元素的集合，是数据的子集。结构是数据元素之间关系的不同性质成为结构。根据数据元素之间的关系的不同性质，通常是。组成，数据项是数据不可分割的最小单位。以熟知各个数据结构方便以后使用！因此又称为数据的逻辑结构。是对客观事物的符号表示。一个数据元素可以由若干个。数据结构是一个二元组。是数据元素的有限集合，数据元素之间的关系集合。
【数据结构】习题 |树与二叉树 |森林 |哈夫曼树 |线索二叉树
2301_77611317的博客
05-19 786
15道题 涉及树与二叉树、哈夫曼树、线索二叉树、森林等知识点本文主要介绍了15道涉及到树与二叉树、哈夫曼树、线索二叉树、森林等知识点的练习题如果文章的论述或代码等出现错误，欢迎前来指正！
一篇讲透数据结构之链式队列
duanku111的博客
05-22 869
队列（queue）是一种只允许在一端进行插入操作，而在另一端进行删除操作的线性表。其严格遵循。队列与栈类似，实现方式有两种。一种是以的方式实现，另一种以来实现。这两种实现方式各有优劣，并且都有细节需要处理。
【数据结构】解密链表之旅（双链表篇）
萌新的博客
05-20 1859
对于单向链表，由于每个节点只存储了向后的指针，到了尾标志就停止了向后的操作，这样，某一节点就无法找到它的前驱节点，就像我们无法回到从前。
【java-数据结构19-队列的模拟实现】
2302_80519942的博客
05-21 744
（这个才是重点）同上，没有元素直接返回即可，只有一个元素（全部置空），普通情况（rear等于前驱，rear置为空），
22.HashMap的底层数据结构
xiaolin的博客
05-15 236
其中，桶数组是用来存储数据元素，链表是用来解决冲突（哈希冲突：多个键通过哈希函数处理后得到相同的哈希值），红黑树是为了提高查询的效率。
【数据结构（邓俊辉）学习笔记】二叉树04——Huffman树
weixin_44399845的博客
05-22 444
学习Huffman树，包括前缀无歧义编码、带权编码成本、编码算法、构造编码树、构造编码表。
C++的数据结构(十二）：图
全栈工程师Linda的博客
05-19 1060
C++的数据结构(十二）：图
数据结构——栈
2302_80339723的博客
05-15 364
1.我们可以定义一个结构体（ struct stack），其中有数组（SLDataType *a），栈顶元素的下标（top）和栈的空间（capacity）。通常为0.我们会将栈为空时状态定义为以下，但是如果将没有元素时top为0，这是top指向的就不是栈顶元素，而是栈顶元素的下一个元素。我们可以实现一个静态栈（数组的长度是一定），但是这种结构并不实用，我们接下来实现的是动态栈。如果不是左括号，就要判断栈是不是为空，若为空，直接返回false，不为空，再取栈顶元素与之比较。总体来说，实现一个栈还是很容易的。
python八卦阴阳
05-13
对于Python的“阴阳”，可能有以下几个方面的讨论： 1. Python的“阴”：Python作为一门解释型语言，其执行效率相对较低，在某些场景下无法满足高性能计算的需求，因此被称为“阴阳”不均衡的一门语言。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿猿收手吧！

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值