数据结构排序：插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序

文章目录

  • 插入排序
  • 希尔排序
  • 选择排序
  • 冒泡排序
  • 堆排序
  • 快速排序

插入排序

  1. 基本思想： 直接插入排序是一种简单的插入排序法，其基本思想是： 把待排序的值按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
  2. 直接插入排序： 当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与 array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

​image​

‍

实现：

//插入排序
void InsertSort(int* a,int n) {

	for (int i = 0; i < n - 1;i++) {
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0) {
			if (tmp < a[end]) {
				a[end + 1] = a[end];
				--end;
			}
			else {
				break;
			}
		}
		a[end + 1] = tmp;
	}

}

直接插入排序的特性总结：

  1. 元素集合越接近有序，直接插入排序算法的时间效率越高

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

  3. 空间复杂度：O(1)，它是一种稳定的排序算法

  4. 稳定性：稳定

‍

希尔排序

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数gap，把待排序文件中所有记录按gap分成若干个组，所有距离为gap的记录分在同一组内，并对每一组内的记录进行排序。然后缩小gap的值，重复上述分组和排序的工作。当到达gap=1时，所有记录在统一组内排好序（当gap=1时其实就是直接插入排序）。

注：希尔排序就是先对待排数组进行一次预排序，将数组变的尽量接近有序，再使用直接插入排序进行最终排序

​image​

实现：

//希尔排序
void ShellSort(int* a,int n) {
	int gap = n;

	while (gap > 1) {

		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i++) {
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0) {
				if (a[end] > tmp) {
					a[end + gap] = a[end];
					end -= gap;
				}
				else {
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}

}

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。

  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的 希尔排序的时间复杂度都不固定

  4. 稳定性：不稳定

选择排序

直接选择排序:

  • 在元素集合array[i]–array[n-1]中选择关键码最大和最小的数据元素
  • 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
  • 在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

​image实现：

//选择排序
void SelectSort(int* a,int n) {

	int min = 0;
	int max = n - 1;
	while (min <= max) {
		int min1 = min;
		int max1 = max;
		for (int i = min; i <= max;i++) {
			if (a[min1] > a[i]) {
				min1 = i;
			}
			if (a[max1] < a[i]) {
				max1 = i;
			}
		}
		Swap(&a[min],&a[min1]);
		if (max1 == min) {
			Swap(&a[max],&a[min1]);
		}
		Swap(&a[max],&a[max1]);
		min++;
		max--;
	}

}

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用

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

  3. 空间复杂度：O(1)

  4. 稳定性：不稳定

冒泡排序

左边大于右边交换一趟排下来最大的在右边

实现：

void Swap(int* a,int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

//冒泡排序
void BubbleSort(int* a,int n) {

	for (int i = n; i > 0;i--) {
		for (int j = 0; j < i - 1; j++) {
			if (a[j] > a[j + 1]) {
				Swap(&a[j],&a[j +1 ]);
			}
		}
	}

}

‍

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序

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

  3. 空间复杂度：O(1)

  4. 稳定性：稳定

堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。

先使用数据进行建堆，在升序排列中，建立一个大堆，建好后最大的数据在最上面，然后将最上面的数据a[0]，与最后位置的数据a[n-1]进行调换，这样a[n-1]位置的数据就是最大的了，最大数据就在了最后面；在对剩下的位置的数据进行调整，再调整为一个大堆，再将a[0]（现在是第二大的数据）与a[n-2]的数据进行调换，这样第二大的数据就砸倒数第二个位置上；后面以次类推，直到堆中仅剩一个数据，排序完成。

需要注意的是排升序要建大堆，排降序建小堆。

对于堆不了解的可以去看我的树与二叉树这一篇文章

实现：

void HeapSort(int* a, int n) {
	//向下调整建小堆
	for (int i = (n - 1 - 1) / 2; i >= 0;i--) {
		AdjustDown(a,n,i);
	}

	int end = n - 1;
	while (end > 0) {
		Swap(&a[0],&a[end]);
		AdjustDown(a,end,0);
		end--;
	}
}

堆排序的特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。

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

  3. 空间复杂度：O(1)

  4. 稳定性：不稳定

快速排序

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

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

// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int array[], int left, int right)
{
 if(right - left <= 1)
 return;

 // 按照基准值对array数组的 [left, right)区间中的元素进行划分
 int div = partion(array, left, right);

 // 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
 // 递归排[left, div)
 QuickSort(array, left, div);

 // 递归排[div+1, right)
 QuickSort(array, div+1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉 树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

实现：

//快排
void QuickSort(int* a,int begin,int end) {
	if (begin >= end) {
		return;
	}
	int mid = GetMid(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int left = begin, right = end;
	int key = begin;
	while (left < right) {
		//右边找小值
		while (left < right && a[right] >= a[left]) {
			right--;
		}
		//左边找大值
		while (left < right && a[left] <= a[key]) {
			left++;
		}
		//如果数组有序，找不到位置，那么此时就会左右相等，不进行交换
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left],&a[key]);
	key = left;

	QuickSort(a,begin,key-1);
	QuickSort(a,key+1,end);
}

改进版：

void Swap(int* a,int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int begin, int end) {
	int mid = (end - begin) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else 
	{
		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 mid = GetMid(a, begin, end);
	Swap(&a[mid], &a[begin]);

	int left = begin, right = end;
	int keyi = begin;

	if (end - begin + 1 < 10) {
		InsertSort(a+begin,end - begin + 1);
	}

	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]);

	return left;
}

挖坑法：

void Swap(int* a,int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int begin, int end) {
	int mid = (end - begin) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else 
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}

//挖坑法块排
int PartSort2(int* a,int begin,int end) {
	int mid = GetMid(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int key = a[begin];
	int hole = begin;
	while (begin < end) {
		//右边找小值
		while (begin < end && a[end] >= key) {
			end--;
		}
		a[hole] = a[end];
		hole = end;
		//左边找大值
		while (begin < end && a[begin] <= key) {
			begin++;
		}
		a[hole] = a[begin];
		hole = begin;
	}

	a[hole] = key;
	return hole;
}

前后指针法：

void Swap(int* a,int* b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

int GetMid(int* a, int begin, int end) {
	int mid = (end - begin) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
			return mid;
		else if (a[begin] > a[end])
			return begin;
		else
			return end;
	}
	else 
	{
		if (a[mid] > a[end])
			return mid;
		else if (a[begin] < a[end])
			return begin;
		else
			return end;
	}
}

//前后指针
int PartSort3(int* a, int begin, int end) {
	int mid = GetMid(a, begin, end);
	Swap(&a[begin], &a[mid]);

	int pre = begin, cur = begin + 1;
	int key = begin;
	while (cur <= end) {
		//cur找小值
		if (a[cur] <= a[key] && ++pre != cur) {
			Swap(&a[pre], &a[cur]);
		}
		cur++;

	}
	Swap(&a[pre], &a[key]);

	return pre;
}

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

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

  3. 空间复杂度：O(logN)

  4. 稳定性：不稳定

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

基于STL的演讲比赛流程管理系统(个人学习笔记黑马学习)

基于STL的演讲比赛流程管理系统(个人学习笔记黑马学习)

1、演讲比赛程序需求 1.1比赛规则 学校举行一场演讲比赛&#xff0c;共有12个人参加。比赛共两轮&#xff0c;第一轮为淘汰赛&#xff0c;第二轮为决赛。每名选手都有对应的编号&#xff0c;如 10001~10012比赛方式:分组比赛&#xff0c;每组6个人;第一轮分为两个小组&#xff…
阅读更多...
Leetcode日记 226. 翻转二叉树 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

Leetcode日记 226. 翻转二叉树 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

Leetcode日记 226. 翻转二叉树 给你一棵二叉树的根节点 root &#xff0c;翻转这棵二叉树&#xff0c;并返回其根节点。 二叉树简介二叉树分类解题方法制作不易&#xff0c;感谢三连&#xff0c;谢谢啦 二叉树简介 二叉树&#xff08;Binary Tree&#xff09;是一种特殊的树形…
阅读更多...
读写分离的利器——MySQL Proxy

读写分离的利器——MySQL Proxy

0 引言 MySQL Proxy是一个位于客户端和MySQL服务器端之间的程序&#xff0c;通过它可以实现监听和管理客户端与MySQL服务器端之间的通信&#xff0c;最大的作用是实现数据库的读写分离&#xff0c;从而达到负载均衡的目的。 MySQL Proxy的常用用途包括负载平衡、故障分析、查…
阅读更多...
神经网络——循环神经网络（RNN）

神经网络——循环神经网络（RNN）

神经网络——循环神经网络&#xff08;RNN&#xff09; 文章目录 神经网络——循环神经网络&#xff08;RNN&#xff09;一、循环神经网络&#xff08;RNN&#xff09;二、循环神经网络结构1、一对一&#xff08;One to One&#xff09;2、一对多&#xff08;One to Many&#…
阅读更多...
Vue中$root的使用方法

Vue中$root的使用方法

查看本专栏目录 关于作者 还是大剑师兰特&#xff1a;曾是美国某知名大学计算机专业研究生&#xff0c;现为航空航海领域高级前端工程师&#xff1b;CSDN知名博主&#xff0c;GIS领域优质创作者&#xff0c;深耕openlayers、leaflet、mapbox、cesium&#xff0c;canvas&#x…
阅读更多...
二次元风格个人主页HTML源码

二次元风格个人主页HTML源码

源码介绍 直接上传服务器压缩包解压就完事了&#xff0c;修改index.html内代码即可&#xff0c;注释写的很全&#xff0c;替换图片在文件夹img&#xff0c;只有前端&#xff0c;没有后台&#xff0c;大佬如果需要&#xff0c;可以自行添加后台。本源码非常适合个人工作室主页。…
阅读更多...
基于ant的图片上传组件封装(复制即可使用)

基于ant的图片上传组件封装(复制即可使用)

/*** 上传图片组件* param imgSize 图片大小限制* param data 上传数据* param disabled 是否禁用*/import React, { useState,useEffect } from react; import { Upload, Icon, message} from antd; const UploadImage ({imgSize 50,data { Directory: Image },disabled f…
阅读更多...
【Python代码】 剪辑法欠采样 CNN压缩近邻法欠采样

【Python代码】 剪辑法欠采样 CNN压缩近邻法欠采样

借鉴&#xff1a;关于K近邻&#xff08;KNN&#xff09;&#xff0c;看这一篇就够了&#xff01;算法原理&#xff0c;kd树&#xff0c;球树&#xff0c;KNN解决样本不平衡&#xff0c;剪辑法&#xff0c;压缩近邻法 - 知乎 一、剪辑法 当训练集数据中存在一部分不同类别数据的…
阅读更多...
105.网游逆向分析与插件开发-网络通信封包解析-分析接收到的对话数据包

105.网游逆向分析与插件开发-网络通信封包解析-分析接收到的对话数据包

内容参考于&#xff1a;易道云信息技术研究院VIP课 上一个内容&#xff1a;接收数据的初步逆向分析 通过上一个内容&#xff0c;找到了数据包出现的一个很重要的位置&#xff0c;只要hook之后就能很好的得到这个数据了 然后来到明文数据的位置&#xff0c;把数据包复制出来&…
阅读更多...
网站管理新利器：免费在线生成 robots.txt 文件！

网站管理新利器：免费在线生成 robots.txt 文件！

&#x1f916; 探索网站管理新利器&#xff1a;免费在线生成 robots.txt 文件&#xff01; 你是否曾为搜索引擎爬虫而烦恼&#xff1f;现在&#xff0c;我们推出全新的在线 robots.txt 文件生成工具&#xff0c;让你轻松管理网站爬虫访问权限&#xff0c;提升网站的可搜索性和…
阅读更多...
代码随想录算法训练营第五十六天|300.最长递增子序列 ， 674. 最长连续递增序列 ，718. 最长重复子数组

代码随想录算法训练营第五十六天|300.最长递增子序列 ， 674. 最长连续递增序列 ，718. 最长重复子数组

300.最长递增子序列 今天开始正式子序列系列&#xff0c;本题是比较简单的&#xff0c;感受感受一下子序列题目的思路。 视频讲解&#xff1a;动态规划之子序列问题&#xff0c;元素不连续&#xff01;| LeetCode&#xff1a;300.最长递增子序列_哔哩哔哩_bilibili 代码随想录…
阅读更多...
TLS、运输层安全协议

TLS、运输层安全协议

目录 运输层安全协议 1 协议 TLS 的要点 1.1 协议 TLS 的位置 1.2 TLS 与应用层协议独立无关 1.3 协议 TLS 具有双向鉴别的功能 1.4 TLS 建立安全会话的工作原理 TLS 的握手阶段 TLS 的会话阶段 1.5 TLS 传送的记录格式 2 协议 TLS 必须包含的措施 运输层安全协议 现…
阅读更多...
OpenAI取消GPT-4 Turbo每日限制，速率提升一倍；扩散模型的理论基础

OpenAI取消GPT-4 Turbo每日限制，速率提升一倍；扩散模型的理论基础

&#x1f989; AI新闻 &#x1f680; OpenAI取消GPT-4 Turbo每日限制&#xff0c;速率提升一倍 摘要&#xff1a;OpenAI宣布取消GPT-4 Turbo的每日限制&#xff0c;提升速率限制1倍&#xff0c;每分钟可处理高达150万TPM的数据。 OpenAI解释速率限制对防止API滥用、确保公平访…
阅读更多...
泰山派摄像头使用-opencv流程

泰山派摄像头使用-opencv流程

1. 泰山派添加camera 连接摄像头连接到usb接口,查看dev设备: # 在终端中输入如下命令&#xff0c;可以查看到camera设备资源&#xff1a; ls /dev/video* 检查板卡上的camera设备资源示例 也可以使用v4l2命令查看 v4l2-ctl --list-devices v4l2-ctl --list-devices是一个命令…
阅读更多...
如何构建企业专属GPT

如何构建企业专属GPT

大语言模型&#xff08;LLM&#xff09;具有令人印象深刻的自然语言理解和生成能力&#xff0c; 2022年11月底OpenAI发布了ChatGPT&#xff0c;一跃成为人工智能AI领域的现象级应用。但由于LLM的训练数据集主要来源于互联网数据&#xff0c;企业私域信息并未被LLM所训练&#x…
阅读更多...
【RPG Maker MV 仿新仙剑 战斗场景UI （二）】

【RPG Maker MV 仿新仙剑 战斗场景UI （二）】

RPG Maker MV 仿新仙剑 战斗场景UI 二 战斗指令菜单原仙剑战斗指令图RMMV战斗指令对应代码战斗指令菜单代码效果 战斗指令菜单 原仙剑战斗指令菜单是使用方向键控制&#xff0c;同时按照使用情况正好对应四个指令和四个方向&#xff0c;同时没有选中的菜单用黑色透明图片覆盖&…
阅读更多...
基于数字双输入的超宽带Doherty功率放大器设计-从理论到ADS版图

基于数字双输入的超宽带Doherty功率放大器设计-从理论到ADS版图

基于数字双输入的超宽带Doherty功率放大器设计-从理论到ADS版图 参考论文: 高效连续型射频功率放大器研究 假期就要倒计时啦&#xff0c;估计是寒假假期的最后一个博客&#xff0c;希望各位龙年工作顺利&#xff0c;学业有成。 全部工程下载&#xff1a;基于数字双输入的超宽…
阅读更多...
npm run dev运行出现NODE_OPTIONS=--max_old_space_size=4096 vite --mode dev --host？

npm run dev运行出现NODE_OPTIONS=--max_old_space_size=4096 vite --mode dev --host？

问题描述 PS E:\AWorkDataease\DataEase\core\core-frontend> npm run dev dataease0.0.0 dev NODE_OPTIONS–max_old_space_size4096 vite --mode dev --host 0.0.0.0 ‘NODE_OPTIONS’ 不是内部或外部命令&#xff0c;也不是可运行的程序 或批处理文件。 解决方案 遇到…
阅读更多...
Linux RabbitMQ 安装及卸载

Linux RabbitMQ 安装及卸载

一、安装 1、前景 RabbitMQ是用Erlang编写的&#xff0c;所以需要先安装Erlang的编译环境 注意 Erlang和RabbitMQ的版本是有一些版本匹配关系的&#xff0c;如果不匹配会导致RabbitMQ无法启动 2、安装Erlang # 下载 wget https://packages.erlang-solutions.com/erlang/r…
阅读更多...
使用纯 CSS 实现元素高度的过渡（不采用 max-height）

使用纯 CSS 实现元素高度的过渡（不采用 max-height）

1. 前言 不知大家是否接触过元素高度的过渡&#xff0c;之前呢我是使用 CSS 加 JS 的方式来解决的&#xff0c;就是通过 JS 计算一下要过渡的元素的高度&#xff0c;然后自己给它加上 height 为某一数值。不知大家是如何解决的&#xff1f; 相信大家在做高度过渡时&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023