常见的排序算法【总结】

目录

排序的基本概念与分类

排序就是将一组杂乱无章的数据按照一定的规律(升序或降序)组织起来。
在排序问题中,通常将数据元素称为记录。 可以将排序看成是线性表的一种操作。

排序的稳定性

排序算法平均时间复杂度最好情况最坏情况空间复杂度稳定性
冒泡排序O(n2)O(n)O(n2)O(1)稳定
简单选择排序O(n2)O(n2)O(n2)O(1)不稳定
插入排序O(n2)O(n)O(n2)O(1)稳定
希尔排序O(nlogn) ~ O(n2)O(n1.3)O(n2)O(1)不稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
归并排序O(nlogn)O(nlogn)O(nlogn)O(n)稳定
快速排序O(nlogn)O(nlogn)O(n2)O(logn)~O(n)不稳定

假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳定的;否则称为不稳定的。
稳定的:冒泡、插入、归并;
不稳定:选择、希尔、快速、堆排序

  • 内部排序:数据元素全部放在内存中的排序。
  • 外排排序:数据元素太多不能同时放在内存中,根据排序过程的要求不能在内外存之间移动数据的排序。

内排序与外排序

内排序是排序整个过程中,待排序的所有记录全部被放置在内存中。

  • 根据排序过程中借助的主要操作,内排序分为插入排序交换排序选择排序归并排序
    外排序是由于排序的记录个数太多,不能同时放置在内存中,整个排序过程需要在内外存之间多次交换数据才能进行。

简单排序

冒泡、选择、插入排序都是简单排序,最坏情况下的时间复杂度都是 O ( n 2 ) O(n^2) O(n2) ,二平方阶随着输入规模的增大,事件成本将急剧上升,所以这些基本排序方法不能处理更大规模的问题。

冒泡排序

冒泡排序(Bubble Sort)是一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止。

时间复杂度: O ( n 2 ) O(n^2) O(n2)

C#代码:

public class Bubble
{/// <summary>/// 正宗的冒泡排序/// </summary>/// <param name="nums"></param>public void BubbleSort(int[] nums){int i, j;for (i = 1; i < nums.Length; i++){for (j = nums.Length - 1; j >= i; j--){if (nums[j] < nums[j - 1]){Swap(nums,j,j-1);}}}}/// <summary>/// 优化后的冒泡排序/// </summary>/// <param name="nums"></param>public void BubbleSort1(int[] nums){int i, j;bool flag = true;for (i = 1; i < nums.Length && flag; i++){flag = false;for (j = nums.Length - 1; j >= i; j--){if (nums[j] < nums[j - 1]){Swap(nums,j,j-1);flag = true;}}}}private void Swap(int[] nums,int i, int j){(nums[i], nums[j]) = (nums[j], nums[i]);}
}

简单选择排序

排序原理:
  1. 在待排序数组中选出最小的(或最大)的与第一个位置的数据交换 然后在剩下的待排序数组中找出最小(或最大)的与第二个位置的数据交换,以此类推,直到第n-1个元素。
  2. 简单选择排序可以说是冒泡排序的一种改版,它不再两两比较出较小数就进行交换,而是每次遍历比较当前数的后面所有数,最后再把最小的数和当前数进行交换。
时间复杂度: O ( n 2 ) O(n^2) O(n2)

image.png

C#代码:

 public void Select(int[] nums){int min;for (int i = 0; i < nums.Length-1; i++){min = i;for (int j = i+1; j < nums.Length; j++){if (nums[j]<nums[min]){min = j;}}(nums[i], nums[min]) = (nums[min], nums[i]);}}

插入排序

插入排序(Insertion sort)是一种简单直观且稳定的排序算法。

插入排序的工作方式非常像人们排序一手扑克牌一样。开始时,我们的左手为空并且桌子上的牌面朝下。然后,我们每次从桌子上拿走一张牌并将它插入左手中正确的位置。为了找到一张牌的正确位置,我们从右到左将它与已在手中的每张牌进行比较

排序原理:
  1. 把所有的元素分为两组,已经排序的和未排序的;
  2. 找到未排序的组中的第一个元素,向已经排序的组中进行插入
  3. 倒叙遍历已经排序的元素,依次和待插入的元素进行比较,直到找到一个元素小于等于待插入元素,那么就把待插入元素放到这个位置,其他的元素向后移动一位;
时间复杂度: O ( n 2 ) O(n^2) O(n2)

C#代码:

public void Insertion(int[] nums){for (int i = 1; i < nums.Length; i++){for (int j = i; j > 0; j--){if (nums[j-1]>nums[j]){//交换元素(nums[j - 1], nums[j]) = (nums[j], nums[j - 1]);}elsebreak;}}}

高级排序

希尔排序

希尔排序是插入排序的一种,又称“缩小增量排序”,是插入排序算法的一种更高效的改进版本。

前面学习插入排序的时候,我们会发现一个很不友好的事儿,如果已排序的分组元索为{2,5,7,9,10},未排序的分组元素为{1,8},那么下一个待插入元素为1,我们需要拿着1从后往前,依次和10,9,7,5,2进行交换位置,才能完成真正的插入,每次交换只能和相邻的元素交换位置。那如果我们要提高效率,直观的想法就是一次交换,能把1放到更前面的位置,比如一次交换就能把1插到2和5之间,这样-次交换1就向前走了5个位置,可以减少交换的次数,这样的需求如何实现呢?接下来我们来看看希尔排序的原理。

排序原理:
  1. 选定一个增长量h,按照增长量h作为数据分组的依据,对数据进行分组
  2. 对分好组的每一组数据完成插入排序;
  3. 减小增长量,最小减为1,重复第二步操作。
    增长量h的确定:我们这里采用以下规则:
int h = 1;
while(h<长度/2)
{h = 2h+1;
}
//循环结束后我们就可以确定h的最大值

h的减小规则为 h = h/2
image.png

C#代码:

public void Shell(int[] nums)
{//确定增长值int h = 1;while (h < nums.Length / 2){h = 2 * h + 1;}while (h>=1){//排序for (int i = h; i < nums.Length; i++){for (int j = i; j >=h ; j-=h){if (nums[j]<nums[j-h]){//交换(nums[j], nums[j - h]) = (nums[j - h], nums[j]);}else{break;}}}h /= 2;}
}

归并排序

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

排序原理:

归并排序算法有两个基本的操作,一个是,也就是把原数组划分成两个子数组的过程。另一个是,它将两个有序数组合并成一个更大的有序数组。

  1. 尽可能的一组数据拆分成两个元素相等的子组,并对每一个子组继续拆分,直到拆分后的每个子组的元素个数是1为止。
  2. 将相邻的两个子组进行合并成一个有序的大组;
  3. 不断的重复步骤2,直到最终只有一个组为止。
时间复杂度: O ( n l o g n ) O(nlogn) O(nlogn)
空间复杂度: O ( N ) O(N) O(N)

归并排序需要一个与原数组相同长度的数组做辅助来排序。

归并排序的缺点

需要申请额外的数组空间,导致空间复杂度提升,是典型的以空间换时间的操作

算法性能

速度仅次于快速排序。
image.png

C#代码:

//递归实现的归并排序
public class MergeSort
{private int[] list;private bool Less(int[] nums,int a, int b){return nums[a] - nums[b] < 0;}public void Sort(int[] nums){int lo = 0;int hi = nums.Length - 1;list = new int[nums.Length];Sort(nums,lo,hi);}private void Sort(int[] nums, int lo, int hi){//安全性校验if (lo>=hi){return;}int mi = lo + (hi - lo) / 2;//分别对每一组数据进行排序Sort(nums,lo,mi);Sort(nums, mi+1, hi);//把两个数组进行归并Merge(nums,lo,mi,hi);}private void Merge(int[] nums, int lo, int mi, int hi){//定义3个指针int p1 = lo;int p2 = mi + 1;int p = lo;//编历,移动p1指针和p2指针,比较对应索引处的值,找出小的那个,放到辅助数组的对应索引处while (p1 <= mi && p2 <= hi){if (Less(nums,p1,p2)){list[p++] = nums[p1++];}else{list[p++] = nums[p2++];}}//如果p1指针没有走完while (p1<=mi){list[p++] = nums[p1++];}//如果p2指针没有走完while (p2<=hi){list[p++] = nums[p2++];}//把辅助数组中的数据拷贝到原数组中for (int i = lo; i <= hi; i++){nums[i] = list[i];}}
}

快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

时间复杂度: O ( n l o g n ) O(nlogn) O(nlogn)
排序原理:
  1. 首先设定一个分界值,通过该分界值将数组分成左右两部分;
  2. 将大于或等于分界值的数据放到到数组右边,小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值,而右边部分中各元素都大于或等于分界值;
  3. 然后,左边和右边的数据可以独立排序。对于左侧的数组数据,又可以取一个分界值,将该部分数据分成左右两部分,同样在左边放置较小值,右边放置较大值。右侧的数组数据也可以做类似处理。
  4. 重复上述过程,可以看出,这是一个递归定义。通过递归将左侧部分排好序后,再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后,整个数组的排序也就完成了

image.png

切分原理:

把一个数组切分成两个子数组的基本思想

  1. 找一个基准值,用两个指针分别指向数组的头部和尾部
  2. 先从尾部向头部开始搜索一个比基准值小的元素,搜索到即停止,并记录指针的位置
  3. 再从头部向尾部开始搜索一个比基准值大的元素,搜索到即停止,并记录指针的位置
  4. 交换当前左边指针位置和右边指针位置的元素
  5. 重复2,3,4步骤,直到左边指针的值大于右边指针的值停止。

C#代码:

//快速排序主要有三个参数,left 为区间的开始地址,right 为区间的结束地址,Key 为当前的开始的值。
//我们从待排序的记录序列中选取一个记录(通常第一个)作为基准元素(称为key)key=arr[left],然后设置两个变量,left指向数列的最左部,right 指向数据的最右部。
public class QuickSort
{public void Sort(int[] arr){Quick(arr, 0, arr.Length - 1);}private void Quick(int[] arr, int left, int right){if (left < right){int pivot = Partition(arr, left, right);Quick(arr, left, pivot - 1);Quick(arr, pivot + 1, right);}}private int Partition(int[] arr, int left, int right){int pivotKey = arr[left];while (left < right){while (left < right && arr[right] >= pivotKey){right--;}arr[left] = arr[right];while (left < right && arr[left] <= pivotKey){left++;}arr[right] = arr[left];}arr[left] = pivotKey;return left;}
}
快速排序和归并排序的区别:

快速排序是另外一种分治的排序算法,它将一个数组分成两个子数组,将两部分独立的排序。快速排序和归并排序是互补的:归并排席将数组分成两个子数组分别排序,并将有序的子数组归并从而将整个数组排序,而快速排序的方式则是当两个数组都有序时,整个数组自然就有序了。在归并排序中,一个数组被等分为两半,归并调用发生在处理整个数组之前,在快速排序中,切分数组的位置取决于数组的内容,递归调用发生在处理整个数组之后。

堆排序

堆排序相当于简单选择排序的升级,他们同属于选择排序类。堆的结构可以分为大顶堆和小顶堆,是一个完全二叉树,而堆排序是根据堆的这种数据结构设计的一种排序。

大顶堆和小顶堆

性质:每个结点的值都大于或等于其左孩子和右孩子结点的值,称之为大顶堆;每个结点的值都小于或等于其左孩子和右孩子结点的值,称之为小顶堆。如下图

image.png

上面的结构映射成数组
image.png

查找数组中某个数的父结点和左右孩子结点,比如已知索引为i的数,那么

1.父结点索引:(i-1)/2(这里计算机中的除以2,省略掉小数)

2.左孩子索引:2*i+1

3.右孩子索引:2*i+2

所以上面两个数组可以脑补成堆结构,因为他们满足堆的定义性质:

大顶堆:arr(i)>arr(2*i+1) && arr(i)>arr(2*i+2)

小顶堆:arr(i)<arr(2*i+1) && arr(i)<arr(2*i+2)

堆排序基本原理:
  1. 首先将待排序的数组构造成一个大顶堆,此时,整个数组的最大值就是堆结构的顶端

  2. 将顶端的数与末尾的数交换,此时,末尾的数为最大值,剩余待排序数组个数为n-1

  3. 将剩余的n-1个数再构造成大根堆,再将顶端数与n-1位置的数交换,如此反复执行,便能得到有序数组
    图片原文https://www.cnblogs.com/sunshineliulu/p/12995910.html
    C#代码:

public class HeapSort  
{  public static void Sort(int[] arr)  {  int n = arr.Length;  // 构建最大堆:大顶堆的构建过程就是从最后一个非叶子结点开始从下往上调整,则最后一个非叶子结点的位置是:数组长度/2-1。  for (int i = n / 2 - 1; i >= 0; i--)  Heapify(arr, n, i);  // 排序for (int i = n - 1; i >= 0; i--)  {  // 将当前最大的元素 arr[0] 和 arr[i] 交换  Swap(arr, 0, i);  // 重新调整剩余元素为最大堆  Heapify(arr, i, 0);  }  }  // 调整以 pos 为根的子树,使其保持最大堆的性质  private static void Heapify(int[] arr, int n, int pos)  {  int largest = pos; // 初始化 largest 为根  int left = 2 * pos + 1; // 左子节点  int right = 2 * pos + 2; // 右子节点  // 如果左子节点比根大  if (left < n && arr[left] > arr[largest])  largest = left;  // 如果右子节点比当前最大的还大  if (right < n && arr[right] > arr[largest])  largest = right;  // 如果最大的不是根  if (largest != pos)  {  // 交换  Swap(arr, pos, largest);  // 递归地调整受影响的子树  Heapify(arr, n, largest);  }  }  // 交换数组中的两个元素  private static void Swap(int[] arr, int i, int j)  {  (arr[i], arr[j]) = (arr[j], arr[i]);  }  
}

排序算法的选择

没有十全十美的排序方法,有优点就会有缺点。即使是快速排序,也只是在整体性能上优越,它也存在排序不稳定、需要大量辅助空间、对少量数据排序无优势等不足。

空间复杂度来说,归并排序强调要马跑得快,就得给马吃个饱。快速排序也有相应的空间要求,反而堆排序等却都是少量索取,大量付出,对空间要求是0(1)。如果执行算法的软件所处的环境非常在乎内存使用量的多少时,选择归并排序和快速排序就不是一个较好的决策了。

稳定性来看,归并排序独占鳌头,我们前面也说过,对于非常在乎排序稳定性的应用中,归并排序是个好算法。

从待排序记录的个数上来说,待排序的个数n越小,采用简单排序方法越合适。反之,n越大,采用高级排序方法越合适。

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

晶方科技:台积电吃饱,封装迎春?

半导体产业链掀起涨价潮&#xff0c;先进封装迎接利好。 这里我们来聊国内先进封装企业——晶方科技。 近期&#xff0c;由于产能供不应求&#xff0c;台积电决定上调先进封装产品价格&#xff0c;还表示订单已经排到2026年。 大哥吃不下了&#xff0c;剩下的订单全都是空间。…

JDK 23:Loom改进版发布

1.新版 Loom EA 改进虚拟线程中的监视器&#xff08;同步方法&#xff09; Project Loom 发布了新的抢先体验版本(23-loom4-102 - 2024/5/31)。改进了对象监视器实现&#xff0c;可以防止虚拟线程在以下情况下固定其载体线程&#xff1a; 当进入同步方法/语句时发生阻塞&…

问题-python-爬虫无法爬取外网资源问题(python爬虫)

方法一&#xff1a; 这个报错通过关掉梯子就能解决&#xff0c;目前不清楚具体原理。 后续了解具体原理了&#xff0c;我会在这篇文章上更新具体分析—— 方法二&#xff1a; 也可以把这个东西打开&#xff0c;但是用完建议关掉。

python无法安装scipy怎么办

python安装scipy时出现以下错误&#xff1a; from scipy.misc import imread Traceback (most recent call last):File "D:/Pyproject/qq_Spider/create_cloud.py", line 14, in <module>from scipy.misc import imread ModuleNotFoundError: No module named …

浅析Kubernetes的权限控制模型

Kubernetes是一个开源的容器编排引擎&#xff0c;用来对容器化应用进行自动化部署、扩缩和管理。它是一个强大的集群管理系统&#xff0c;提供了丰富的功能。他的一个核心组件是Kubernetes API Server&#xff0c;这是集群中所有资源管理的入口点&#xff0c;提供了一组RESTful…

spring boot jar 启动报错 Zip64 archives are not supported

spring boot jar 启动报错 Zip64 archives are not supported 原因、解决方案问题为什么 spring boot 不支持 zip64zip、zip64 功能上的区别zip 的文件格式spring-boot-loader 是如何判断是否是 zip64 的&#xff1f; 参考 spring boot 版本是 2.1.8.RELEASE&#xff0c;引入以…

北京崇文门中医医院贾英才主任:脑梗治疗新探索

脑梗&#xff0c;是众多患者心中的阴霾&#xff0c;它的突然来袭&#xff0c;常常让人猝不及防。 一旦发作&#xff0c;偏瘫、失语等症状接踵而至&#xff0c;给患者及其家庭带来沉重的打击&#xff0c;极大地影响了生活的质量。 造成脑梗频发的原因究竟是什么&#xff1f;中…

Golang | Leetcode Golang题解之第173题二叉搜索树迭代器

题目&#xff1a; 题解&#xff1a; type BSTIterator struct {stack []*TreeNodecur *TreeNode }func Constructor(root *TreeNode) BSTIterator {return BSTIterator{cur: root} }func (it *BSTIterator) Next() int {for node : it.cur; node ! nil; node node.Left {it…

Docker部署前端,动态配置后端地址

本文介绍了使用Docker环境变量动态配置nginx。采用的是通过docker run -e xxxxxxx先往容器注入环境变量&#xff0c;然后进一步通过envsubst指令将环境变量写入到conf文件中&#xff0c;实现动态配置文件内容。 背景 前后端分离的架构下&#xff0c;经常会用到nginx反向代理来…

粉末冶金5G智能工厂工业物联数字孪生平台,推进制造业数字化转型

粉末冶金5G智能工厂工业物联数字孪生平台&#xff0c;推进制造业数字化转型。在数字化浪潮席卷全球的今天&#xff0c;制造业的数字化转型已然成为不可逆转的趋势。粉末冶金行业&#xff0c;作为制造业的重要一环&#xff0c;亦需紧跟时代步伐&#xff0c;以5G智能工厂、工业物…

【SpringSecurity】认证与鉴权框架SpringSecurity——授权

目录 权限系统的必要性常见的权限管理框架SpringSecurity授权基本流程准备脚本限制访问资源所需权限菜单实体类和Mapper封装权限信息封装认证/鉴权失败处理认证失败封装鉴权失败封装配置SpringSecurity 过滤器跨域处理接口添加鉴权hasAuthority/hasAnyAuthorityhasRole/​ hasA…

针对知识图谱使用 Mistral-7b 从简历中提取实体

翻译&#xff1a;“Entity Extraction from Resume using Mistral-7b for Knowledge Graphs” | by Tejpal Kumawat | Feb, 2024 | Medium[1] 在快速发展的自然语言处理&#xff08;NLP&#xff09;领域&#xff0c;从非结构化文本源中准确提取和分析信息的能力变得越来越重要。…

ravynOS 0.5.0 发布 - 基于 FreeBSD 的 macOS 兼容开源操作系统

ravynOS 0.5.0 发布 - 基于 FreeBSD 的 macOS 兼容开源操作系统 ravynOS - 一个旨在提供 macOS 的精致性和 FreeBSD 的自由度的操作系统 请访问原文链接&#xff1a;https://sysin.org/blog/ravynos/&#xff0c;查看最新版。原创作品&#xff0c;转载请保留出处。 作者主页…

snakeyaml从1.x升级2.x的方案

一、背景 因公司漏洞扫描&#xff0c;发现SnakeYAML 反序列化漏洞(CVE-2022-1471)&#xff0c;所以要求对SnakYaml进行升级。 因项目中未直接引用snakyaml包&#xff0c;经分析是springboot引用的这个包。但是在这个项目中&#xff0c;springboot用的版本是2.3.12.RELEASE版本…

睡眠剥夺对记忆巩固的神经生物学影响

近期&#xff0c;《自然》杂志刊载的研究揭示了睡眠不足对记忆相关神经信号的不利影响&#xff0c;强调了即使在后续恢复充分睡眠的情况下&#xff0c;这种损害亦难以完全逆转。 神经元作为大脑的基本功能单位&#xff0c;其活动并非孤立进行&#xff0c;而是通过复杂的网络连接…

Cesium--旋转3dtiles

以下代码来自Cesium 论坛&#xff1a;3DTileset rotation - CesiumJS - Cesium Community 在1.118中测试可行&#xff0c;可直接在Sandcastle中运行&#xff1a; const viewer new Cesium.Viewer("cesiumContainer", {terrain: Cesium.Terrain.fromWorldTerrain()…

机器学习课程复习——线性回归

Q&#xff1a;回归和分类的区别&#xff1f; 回归是连续的&#xff0c;分类是离散的 Q:用最小二乘法对线性回归模型进行参数估计思路 例题

vue+three.js渲染3D模型

安装three.js: npm install three 页面部分代码&#xff1a; <div style"width: 100%; height: 300px; position: relative;"><div style"height: 200px; background-color: white; width: 100%; position: absolute; top: 0;"><div id&…

go语言day4 引入第三方依赖 整型和字符串转换 进制间转换 指针类型 浮点数类型 字符串类型

Golang依赖下载安装失败解决方法_安装go依赖超时怎么解决-CSDN博客 go安装依赖包&#xff08;go get, go module&#xff09;_go 安装依赖-CSDN博客 目录 go语言项目中如何使用第三方依赖&#xff1a;&#xff08;前两步可以忽略&#xff09; 一、安装git&#xff0c;安装程序…