七大排序思想

news2025/2/7 7:04:27

目录

七大排序的时间复杂度和稳定性

排序

插入排序

简单插入排序

希尔排序

选择排序

简单选择排序

堆排序

交换排序

冒泡排序

快速排序

快排的递归实现 

hoare版本的快排

 挖坑法的快排

双指针法的快排

快排的非递归

归并排序

归并的递归实现

归并的非递归实现

补充

快排的三路划分

七大排序的时间复杂度和稳定性

排序时间的复杂度和稳定性-CSDN博客关于七大排序的时间复杂度和稳定性的总结，帮助读者迅速掌握各各排序的优劣，在不同情况下如何选择。 https://blog.csdn.net/2401_87944878/article/details/145404375

排序

排序就是将一组数据按照递增或递减的方式将其排列。

排序包含两种；

内部排序：数据元素全部放在内存中的排序。

外部排序：数据太多不能同时放在内存中，根据排序的过程不能在内外存之间移动的排序。外部排序要对文件进行操作。

排序包含有四大实现：插入排序，选择排序，交换排序，归并排序。根据这四个实现又可以分支出一共7个排序思想：简单插入排序，希尔排序；选择排序，堆排序；冒泡排序，快速排序；归并排序。下面我们对这七种排序进行讲解。

插入排序

插入排序包含两种：简单插入排序，希尔排序。

简单插入排序

如图，简单插入怕排序就是遍历原数组，将每一个元素放在其指定位置。先拿出一个元素，向前找看，比它大的先后移，直到找到比它小的。

//简单插入排序
void InsertSort(int* a, int n)
{
	//插入排序，向前找到元素的指定位置
	for (int i = 1; i < n; i++)
	{
		int end = i;
		int cur = a[end];
		while(end>0)
		{
			if (a[end - 1] > cur)
			{
				a[end] = a[end - 1];
				end--;
			}
			else
				break;
		}
		a[end] = cur;
	}
}

希尔排序

 希尔排序实际上是对简单插入排序的一种优化。简单插入排序每次与其相邻的元素进行比较，而希尔排序是将一个数组分成多个组，将每个组进行简单插入排序，这样可以让大的数迅速到前面去，小的数迅速到后面去。

可以看到第一次gap是5时，将下标0和5比较，1和6比较，2和7比较....这样可以迅速将大的数移到前面去，将小的数移到后面去，这样就使的数组更加趋于有序的状态。

通过gap从大到小的变化，使得当gap较小的时候可以快速向前找到它的位置，更快的让每次循环break掉，让效率更快。

//希尔排序
void ShellSort(int* a, int n)
{
	//希尔排序与插入排序的区别在于，其先进行预排序
	int gap = n;
	while (gap > 1)
	{
		gap /= 2;
		for (int i = 0; i < gap; i++)
		{
			for (int m = i + gap; m < n; m += gap)
			{
				int end = m;
				int cur = a[end];
				while (end > 0)
				{
					if (a[end - 1] > cur)
					{
						a[end] = a[end - 1];
						end--;
					}
					else
						break;
				}
				a[end] = cur;
			}
		}

	}
}

选择排序

选择排序包含两种简单选择排序和堆排序；

简单选择排序

简单选择排序就是遍历原数组，直接找到最大值或最小值将其放在尾和首，可以一次只找出一个最值，也可以将最大值和最小值同时找到。

以上是遍历未排序的数组每次找出最下的元素交换，下面演示遍历未排序的数组每次找打最小和最大的元素。 

//交换函数
void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}


//简单选择排序
void SelectSort(int* a, int n)
{
	//一次遍历，选出最大值和最小值
	int left = 0;
	int right = n - 1;
	while (left < right)
	{
		int min = left;
		int max = left;
		for (int i = left; i <= right; i++)
		{
			if (a[min] > a[i])
				min = i;
			if (a[max] < a[i])
				max = i;
		}
		//交换
		Swap(&a[left], &a[min]);
		//注意此处，如果left对应的值就是最大值的时候，
		//将min和left交换后，max就在min的位置了
		if (left == max)
			Swap(&a[right], &a[min]);
		else
			Swap(&a[right], &a[max]);
		left++, right--;
	}
}

堆排序

堆排序就是利用二叉树的性质，通过建大堆或小堆，将最大的数据或最小的数据放在指定位置。在二叉树中已经详细讲过堆了，这里就直接贴代码。

二叉树（C语言）-CSDN博客文章浏览阅读1.3k次，点赞19次，收藏18次。帮助读者快速掌握树这一数据结构，了解堆的功能，能够实现堆排序，以及如何再大量数据中快速找到前K个最大元素，如何处理普通二叉树，普通二叉树的遍历等知识。https://blog.csdn.net/2401_87944878/article/details/145262931https://blog.csdn.net/2401_87944878/article/details/145262931https://blog.csdn.net/2401_87944878/article/details/145262931https://blog.csdn.net/2401_87944878/article/details/145262931https://blog.csdn.net/2401_87944878/article/details/145262931https://blog.csdn.net/2401_87944878/article/details/145262931

//向下调整
void AdjustDown(int* a, int n, int parent)
{
	int child = 2 * parent + 1;

	while (child < n)
	{
		if (child+1<n&&a[child] < a[child + 1])
			child++;

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
			break;
	}
}


//堆排序
void HeapSort(int* a, int n)
{
	//先建大堆
	for (int i = (n - 2) / 2; i >= 0; i--)
	{
		//向下调整
		AdjustDown(a, n, i);
	}
	//将堆顶的最大值和堆低交换
	int sz = n - 1;
	Swap(&a[0], &a[sz]);
	sz--;
	while (sz > 0)
	{
		AdjustDown(a, sz + 1, 0);
		Swap(&a[0], &a[sz]);
		sz--;
	}
}

交换排序

交换排序分为冒泡排序和快速排序。

冒泡排序

冒泡排序简单，没有实际作用，这里直接贴代码。

//冒泡排序
void BubbleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		for (int m = 0; m < n - 1 - i; m++)
		{
			if (a[m] > a[m + 1])
				Swap(&a[m], &a[m + 1]);
		}
	}
}

快速排序

快速排序是将一个元素key作为基准，先找到这个key的准确位置，将小于key的放在key的左边，将大于key的放在右边。

快排的递归实现 

hoare版本的快排

 如图：将数组首元素作为key，通过左右指针，让R指针先走找到小于key的值停，L指针再走大于key的时候停，将L位置和R位置交换，直到L和R相遇时停止，这个位置就是key排序后的位置。

思考：为什么要让R指针想走？能否让L指针想走？ 

关于key的选择有三种方法：选择最左边的，随机选择，比较数组左右中间这三个值，选出次小的值。此处选择三数取中最好，可以尽量避免只出现一个递归函数。

//快排：Hoare版本
void QuickSort(int* a, int begin,int end)
{
	if (begin >= end)
		return;

	//快排就是将key放在正确位置上去。
	//三数取中
	int mid = Mid(begin, end);
	Swap(&a[begin], &a[mid]);
	int keyi = begin;
	int left = begin;
	int right = end;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
			right--;

		while (left < right && a[left] <= a[keyi])
			left++;
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	keyi = left;

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi+1, end);
}
 挖坑法的快排

利用挖坑法可以直接不用思考数组那一边的指针先走的问题。

挖坑法就是将keyi的位置值保留，R指针找比key小的将其填在keyi的位置，R指针处变为坑，直到L指针和R指针相遇，将其位置的key填入坑。

//快排：挖坑法
void HoleSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int mid = Mid(begin, end);
	Swap(&a[mid], &a[begin]);

	int hole = begin;
	int left = begin;
	int right = end;
	int key = a[hole];

	while (left < right)
	{
		while (left < right && a[right] >= key)
			right--;
		a[hole] = a[right];
		hole = right;
		
		while (left < right && a[left] <= key)
			left++;
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	int keyi = hole;

	HoleSort(a, 0, keyi - 1);
	HoleSort(a, keyi+1, end);
}
双指针法的快排

分别利用两个指针，一个向前面走如果cur对用的值比key小就交换，两个指针都向前移动；如果cur对应的值大就不交换，cur向前移动。

//快排：双指针法
void DPoint(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int mid = Mid(begin, end);
	Swap(&a[begin], &a[mid]);

	int keyi = begin;
	int cur = begin;
	int pre = begin;
	while (cur <= end)
	{
		if (a[cur] <= a[keyi])
		{
			if (cur != pre)
				Swap(&a[cur], &a[pre]);
			cur++;
			pre++;
		}
		else
		{
			cur++;
		}
	}
	Swap(&a[keyi], &a[pre - 1]);
	keyi = pre - 1;

	DPoint(a, begin, keyi - 1);
	DPoint(a, keyi+1, end);
}

快排的非递归

快排的非递归就是利用栈将其begin和end的值储存起来，再利用栈的“后入先出”的性质，每一次拿出一个范围再放入子范围，直到栈的空间为空时停止。

此处以Hoare的非递归为例。

typedef struct Stack
{
	int* a;
	int size;
	int capacity;
}Stack;

//栈的初始化
void StackInit(Stack* sp)
{
	sp->capacity = 4;
	sp->a = (int*)malloc(sizeof(int) * (sp->capacity));
	if (sp->a == NULL)
		perror("malloc failed");

	sp->size = 0;
}

//入栈
void StackPush(Stack* sp, int x)
{
	//检查空间够不够
	if (sp->size == sp->capacity)
	{
		sp->capacity *= 2;
		int* tmp = (int*)realloc(sp->a, sizeof(int) * (sp->capacity));
		if (tmp == NULL)
			perror("realloc failed");
		sp->a = tmp;
	}
	sp->a[sp->size] = x;
	sp->size++;
}

//出栈
void StackPop(Stack* sp)
{
	sp->size--;
}

//返回栈顶元素
int StackTop(Stack* sp)
{
	return sp->a[sp->size - 1];
}

//检查栈空间是否为空
bool IsStackEmpty(Stack* sp)
{
	if (sp->size == 0)
		return true;
	else
		return false;
}
//快排：非递归
void QuickNon(int* a, int begin, int end)
{
	//快排的非递归就是将快排的左右间距存储在栈中
	Stack s;
	StackInit(&s);
	StackPush(&s, end);
	StackPush(&s, begin);

	while (!IsStackEmpty(&s))
	{
		int begin = StackTop(&s);
		StackPop(&s);
		int end = StackTop(&s);
		StackPop(&s);
		int left = begin;
		int keyi = left;
		int right = end;

		while (left < right)
		{
			while (left < right && a[right] >= a[keyi])
				right--;
			while (left < right && a[left] <= a[keyi])
				left++;

			Swap(&a[left], &a[right]);
		}
		Swap(&a[left], &a[keyi]);
		keyi = left;
		
		if (begin < keyi - 1)
		{
			StackPush(&s, keyi - 1);
			StackPush(&s, begin);
		}
		if (keyi + 1 < end)
		{
			StackPush(&s, end);
			StackPush(&s, keyi + 1);
		}
	}
}

归并排序

归并排序的实现就是：先对小范围排序，再对大范围排序。如图：相对两个元素进行排序，再对4个元素进行排序，依次依次*2向后排序。

归并的递归实现

//归并排序
void Merge(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	
	int mid = (begin + end) / 2;
	Merge(a, begin, mid);
	Merge(a, mid + 1, end);

	int begin1 = begin;
	int end1 = mid;
	int begin2 = mid + 1;
	int end2 = end;
	int* tmp = (int*)malloc(sizeof(int) * (end - begin + 1));
	int j = 0;
	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 + begin, tmp, sizeof(int) * (end - begin + 1));
	free(tmp);
}

归并的非递归实现

归并的非递归实现就不能用栈来存储18首尾的范围了，可以直接从2个元素排序开始，依次*2直到排完为止。

//归并的非递归实现
void MergeNon(int* a, int begin, int end)
{
	int gap = 1;
	while (gap < end)
	{
		for (int i = 0; i <= end; i += 2 * gap)
		{
			int begin1 = i;
			int end1 = i + gap - 1;
			int begin2 = i + gap;
			int end2 = i + 2 * gap - 1;
			if (begin2 > end)
			{
				break;
			}
			if (end2 > end)
				end2 = end;

			int* tmp = (int*)malloc(sizeof(int) * (end2 - begin1 + 1));
			int j = 0;
			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, sizeof(int) * (end2-i+1));
			free(tmp);
		}
		gap *= 2;
	}
}

补充

关于快排，当有大量重复的数据出现的时候，快排的key的位置可能就是最左边，导致向下递归后还是只有一组，当大量出现这种情况的时候就会导致快排变成简单选择排序，时间复杂度大大增加，导致效率降低。此处可以采用三路划分的快排解决。

快排的三路划分

三路划分与普通快排的区别：普通快排将数组分成两个部分，大于key和小于key的；而三路划分将快排分成三个部分，大于key，小于key和等于key的。

分为左右两个指针以及一个遍历数组的指针，将大于key的调到右边，将小于key的调到左边，将等于key的放在中间。

//快排的三路划分
void TQuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int mid = Mid(begin, end);
	Swap(&a[begin], &a[mid]);

	int keyi = begin;
	int key = a[begin];
	int left = begin;
	int cur = begin;
	int right = end;

	while (cur <= right)
	{
		if (a[cur] < key)
		{
			if (cur != left)
				Swap(&a[left], &a[cur]);
			left++, cur++;
		}
		else if (a[cur] > key)
		{
			Swap(&a[cur], &a[right]);
			right--;
		}
		else
			cur++;
	}
	keyi = left;

	TQuickSort(a, begin, keyi - 1);
	TQuickSort(a, keyi + 1, end);
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2294167.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

制作PE启动盘（内含Win11 iso镜像）

制作PE启动盘（内含Win11 iso镜像）

前言 本文用于记录制作PE启动盘过程&#xff0c;学习记录用&#xff0c;如有不对请指出&#xff0c;谢谢&#xff01; 参考视频&#xff1a; 1. 微PE下载&#xff1a;https://www.bilibili.com/video/BV1vT4y1n7JX/?spm_id_from333.788.top_right_bar_window_history.conte…
阅读更多...
css字体样式与文本样式详解

css字体样式与文本样式详解

目录 一、CSS字体样式 1. 字体类型&#xff08;font-family&#xff09; 2. 字体大小&#xff08;font-size&#xff09; 3. 字体粗细&#xff08;font-weight&#xff09; 4. 字体风格&#xff08;font-style&#xff09; 5. 字体颜色&#xff08;color&#xff09; 6. …
阅读更多...
游戏引擎学习第89天

游戏引擎学习第89天

回顾 由于一直没有渲染器&#xff0c;终于决定开始动手做一个渲染器&#xff0c;虽然开始时并不确定该如何进行&#xff0c;但一旦开始做&#xff0c;发现这其实是正确的决定。因此&#xff0c;接下来可能会花一到两周的时间来编写渲染器&#xff0c;甚至可能更长时间&#xf…
阅读更多...
Linux学习笔记16---高精度延时实验

Linux学习笔记16---高精度延时实验

延时函数是很常用的 API 函数&#xff0c;在前面的实验中我们使用循环来实现延时函数&#xff0c;但是使用循环来实现的延时函数不准确&#xff0c;误差会很大。虽然使用到延时函数的地方精度要求都不会很严格( 要求严格的话就使用硬件定时器了 ) &#xff0c;但是延时函数肯定…
阅读更多...
杨氏数组中查找某一数值是否存在

杨氏数组中查找某一数值是否存在

判断数据是否存在于杨氏矩阵中 &#xff08;小米真题&#xff09; 题目&#xff1a;有一个数字矩阵&#xff0c;矩阵的每行从左到右是递增的&#xff0c;矩阵从上到下是递增的&#xff0c;请编写程序在这样的矩阵中查找某个数字是否存在。 要求&#xff1a;时间复杂度小于O(N) …
阅读更多...
51单片机 02 独立按键

51单片机 02 独立按键

一、独立按键控制LED亮灭 轻触按键&#xff1a;相当于是一种电子开关&#xff0c;按下时开关接通&#xff0c;松开时开关断开&#xff0c;实现原理是通过轻触按键内部的金属弹片受力弹动来实现接通和断开。 #include <STC89C5xRC.H> void main() { // P20xFE;while(1){…
阅读更多...
AI + 编程时代，飞算JavaAI如何引领行业趋势变革

AI + 编程时代，飞算JavaAI如何引领行业趋势变革

在当今科技飞速发展的浪潮下&#xff0c;AI 与编程的深度融合已成为不可阻挡的时代趋势&#xff0c;正重塑着各个行业的格局。在这场变革中&#xff0c;飞算JavaAI脱颖而出&#xff0c;凭借其卓越的特性和创新的理念&#xff0c;在 AI 编程领域展现出强大的引领力量&#xff0…
阅读更多...
Deepseek本地部署指南：在linux服务器部署，在mac远程web-ui访问

Deepseek本地部署指南：在linux服务器部署，在mac远程web-ui访问

1. 在Linux服务器上部署DeepSeek模型 要在 Linux 上通过 Ollama 安装和使用模型&#xff0c;您可以按照以下步骤进行操作&#xff1a; 步骤 1&#xff1a;安装 Ollama 安装 Ollama&#xff1a; 使用以下命令安装 Ollama&#xff1a; curl -sSfL https://ollama.com/download.…
阅读更多...
1-R语言概述

1-R语言概述

1.认识R语言 1.1 选择R语言的依据 免费的软件编程方便&#xff0c;语言灵活&#xff0c;图形功能强大优秀的内在帮助系统高质量、广泛的统计分析、数据挖掘平台国际上R语言已然是专业数据分析领域的标准 1.2 R的来源 ​ R是S语言的一种实现。S语言是由 AT&T贝尔实验室…
阅读更多...
【BQ3568HM开发板】智能家居中控屏连接华为云IoTDA物联网平台

【BQ3568HM开发板】智能家居中控屏连接华为云IoTDA物联网平台

目录 引言 安装OpenHarmony的MQTT库 华为云平台的操作 建立设备 建立物模型 连接华为云平台 发布LED灯状态 代码重构 测试结果 接收平台发送的属性修改命令 设备侧API Topic 下行请求参数说明 上行响应参数说明 程序修改 应用侧API 测试设备属性设置功能 结语…
阅读更多...
java 8 在 idea 无法创建 java spring boot 项目的 变通解决办法

java 8 在 idea 无法创建 java spring boot 项目的 变通解决办法

java 8 在 idea 无法创建 java spring boot 项目的 变通解决办法 spring boot 3 官方强制 要用 java 17 &#xff0c;但是 不想安装java 17的 &#xff0c;但是又想 使用 spring boot &#xff0c;可以这样 &#xff1a; 在这个网站 https://start.aliyun.com/ 选择 你相对…
阅读更多...
web-文件上传-CTFHub

web-文件上传-CTFHub

前言 在众多的CTF平台当中&#xff0c;作者认为CTFHub对于初学者来说&#xff0c;是入门平台的不二之选。CTFHub通过自己独特的技能树模块&#xff0c;可以帮助初学者来快速入门。具体请看官方介绍&#xff1a;CTFHub。 作者更新了CTFHub系列&#xff0c;希望小伙伴们多多支持…
阅读更多...
SQLAlchemy-2.0中模型定义和alembic的数据库迁移工具

SQLAlchemy-2.0中模型定义和alembic的数据库迁移工具

SQLAlchemy-2.0中模型定义和alembic的数据库迁移工具 一、SQLAIchemy的介绍二、数据库引擎1、支持的数据库1.1、sqlite数据库1.2、MySQL数据库1.3、数据库引擎的参数 三、定义模型类1、定义模型2、engine负责数据库迁移 四、alembic数据库迁移⼯具1、安装alembic2、初始化alemb…
阅读更多...
C# OpenCV机器视觉:图像风格迁移

C# OpenCV机器视觉:图像风格迁移

在一个充满奇思妙想的创意工作室里&#xff0c;小李正像只热锅上的蚂蚁&#xff0c;为客户的项目挠破了脑袋&#xff0c;急需寻找灵感的火花。他望着眼前那幅平淡无奇的风景图像&#xff0c;心想&#xff1a;“这玩意儿也太普通啦&#xff0c;就像一杯白开水&#xff0c;怎么能…
阅读更多...
语言月赛 202311【基因】题解（AC）

语言月赛 202311【基因】题解（AC）

》》》点我查看「视频」详解》》》 [语言月赛 202311] 基因 题目描述 有一个长度为 n n n 的字符串 S S S。其只包含有大写字母。 小 A 将 S S S 进行翻转后&#xff0c;得到另一个字符串 S ′ S S′。两个字符串 S S S 与 S ′ S S′ 对应配对。例如说&#xff0c;对…
阅读更多...
Spring @PropertySource：让你的应用配置更加模块化和可维护

Spring @PropertySource：让你的应用配置更加模块化和可维护

PropertySource注解在Spring中的作用&#xff0c;就像是给Spring应用配了一个“外部配置箱”。 想象一下&#xff0c;你在开发一个Spring应用时&#xff0c;有很多配置信息需要设置&#xff0c;比如数据库的连接信息、应用的某些功能开关等。如果这些信息都硬编码在代码中&…
阅读更多...
Deep Sleep 96小时：一场没有硝烟的科技保卫战

Deep Sleep 96小时：一场没有硝烟的科技保卫战

2025年1月28日凌晨3点&#xff0c;当大多数人还沉浸在梦乡时&#xff0c;一场没有硝烟的战争悄然打响。代号“Deep Sleep”的服务器突遭海量数据洪流冲击&#xff0c;警报声响彻机房&#xff0c;一场针对中国关键信息基础设施的网络攻击来势汹汹&#xff01; 面对美国发起的这场…
阅读更多...
快速搭建GPU环境 | docker、k8s中使用gpu

快速搭建GPU环境 | docker、k8s中使用gpu

目录 一、裸机部署安装 GPU Driver安装 CUDA Toolkit测试 二、Docker 环境安装 nvidia-container-toolkit配置使用该 runtime 三、 k8s 环境安装 device-plugin安装 GPU 监控 一、裸机部署 裸机中要使用上 GPU 需要安装以下组件&#xff1a; GPU DriverCUDA Toolkit 二者的关…
阅读更多...
npm中央仓库

npm中央仓库

1、官网地址 npm | Home 2、搜索依赖包
阅读更多...
2025年软考考试时间及考试科目如何安排？附考试注意事项！

2025年软考考试时间及考试科目如何安排？附考试注意事项！

一、考试时间 2025年软考举行两次考试&#xff0c;分别安排在上半年和下半年。根据最新公布的信息&#xff0c;2025年软考考试的具体时间安排如下&#xff1a; 上半年考试时间&#xff1a;5月24日至5月27日 下半年考试时间&#xff1a;11月8日至11月11日 考生需要在规定的时间内…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023