数据结构——排序大汇总(建议收藏)

这篇文章将为大家详细讲解各大排序的基本思想与实现代码~

内有动图

首先,我们来看常见的排序有以下几大类:

1.插入排序

插入排序的主要思想是将每个位置的元素插入到前面已具备顺序的数组中

实际中我们玩扑克牌时,就用了插入排序的思想  

 

1.1动图展示

 

1.2代码实现

// 插入排序
void InsertSort(int* a, int n)
{//把end+1插入到【0,end】内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];}else {break;}end--;}a[end + 1] = tmp;}}

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

  1. 元素集合越接近有序,直接插入排序算法的时间效率越高
  2. 时间复杂度:O(N^2)
  3. 空间复杂度:O(1),它是一种稳定的排序算法
  4. 稳定性:稳定  

2.希尔排序

希尔排序法又称缩小增量法

希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成个 组,所有距离为的记录分在同一组内,并对每一组内的记录进行排序。然后,取,重复上述分组和排序的工 作。当到达=1时,所有记录在统一组内排好序

2.1动图展示

2.2代码实现

// 希尔排序
void ShellSort(int* a, int n)
{int gap = n;while (gap!=1) {gap=gap/3+1;for (int i = 0; i < gap; i++){for (int j = 0; j < n - gap-1; j += gap)//或者j++变为三重循环{int end = j;int tmp = a[end + gap];while (end >= 0){if (tmp < a[end]){a[end + gap] = a[end];}else {break;}end-=gap;}a[end + gap] = tmp;}}}}

希尔排序的特性总结:

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序,目的是让数组更接近于有序。当gap == 1时,数组已经接近有序的了,这样就 会很快。这样整体而言,可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算,因为gap的取值方法很多,导致很难去计算,因此在好些树中给出的 希尔排序的时间复杂度都不固定,因为咱们的gap是按照Knuth提出的方式取值的,而且Knuth进行了大量的试验统计,我们暂时就按照:O(n^1.25) 到 O(1.6*n^1.25)来算。

3.选择排序

直接选择排序:

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

3.1动图展示

 

3.2代码实现

// 选择排序
void SelectSort(int* a, int n)
{int max;int min;int end = n - 1;int head = 0;while (end > head){max = min = head;for (int i = head; i <= end; i++){if (a[i] < a[min]){min = i;}if (a[i] > a[max]){max = i;}}if (max == head && min == end){Swap(&a[max], &a[end]);}else if (min == end){Swap(&a[min], &a[head]);Swap(&a[max], &a[end]);}else{Swap(&a[max], &a[end]);Swap(&a[min], &a[head]);}end--;head++;}}

上面的方法是选择排序的改进,一趟同时找出最大和最小数 

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

  1. 直接选择排序思考非常好理解,但是效率不是很好。实际中很少使用
  2. 时间复杂度:O(N^2)
  3. 空间复杂度:O(1)
  4. 稳定性:不稳定 

4.堆排序

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆,排降序建小堆

4.1动图展示

 

4.2代码实现

// 堆排序
void AdjustDwon(int* a, int n, int root)
{//建大堆int parent = root;int child = parent * 2 + 1;while (child < n){if (child+1<n &&a[child] < a[child + 1])//要有右孩子才能比较{child++;}if (a[parent] < a[child]){Swap(&a[parent], &a[child]);}parent = child;child = parent * 2 + 1;}
}
void HeapSort(int* a, int n)
{for (int i = (n - 1) / 2; i >= 0; i--){AdjustDwon(a, n, i);}while (n--){Swap(&a[0], &a[n]);AdjustDwon(a, n, 0);}
}

堆排序的特性总结:

  1. 堆排序使用堆来选数,效率就高了很多。
  2. 时间复杂度:O(N*logN)
  3. 空间复杂度:O(1)
  4. 稳定性:不稳定  

5.冒泡排序

交换排序基本思想:

所谓交换,就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置

交换排序的特点是:

将键值较大的记录向序列的尾部移动,键值较小的记录向序列的前部移动。

5.1动图展示

 

5.2代码实现

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

冒泡排序的特性总结:

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度:O(N^2)
  3. 空间复杂度:O(1)
  4. 稳定性:稳定  

6.快速排序

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

6.1 hoare版本

6.1.1动图展示

6.1.2代码实现

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{//三数取中int keyi = Getmid(a, left, right);Swap(&a[keyi], &a[left]);keyi = left;int begin = left;int end = right;while (begin < end){//右边找到小停while (begin < end && a[end] >= a[keyi]){end--;}//左边找到大停while (begin < end && a[begin] <= a[keyi]){begin++;}Swap(&a[begin], &a[end]);}Swap(&a[keyi], &a[begin]);keyi = begin;return keyi;
}
void QuickSort(int* a, int left, int right)
{if (left >= right){return;}//优化小区间if (right - left + 1 < 10){InsertSort(a + left, right - left + 1);return;}int keyi = PartSort1(a,left,right);//int keyi = PartSort2(a, left, right);//int keyi = PartSort3(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);
}

6.2 挖坑法

6.2.1动图展示

6.2.2代码实现

// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{//三数取中int keyi = Getmid(a, left, right);Swap(&a[keyi], &a[left]);keyi = left;int key = a[left];int pit = left;int begin = left;int end = right;while (begin < end){while (begin < end && a[end] >= key){end--;}a[pit] = a[end];pit = end;while (begin < end && a[begin] <= key){begin++;}a[pit] = a[begin];pit = begin;}a[pit] = key;return pit;}
void QuickSort(int* a, int left, int right)
{if (left >= right){return;}//优化小区间if (right - left + 1 < 10){InsertSort(a + left, right - left + 1);return;}//int keyi = PartSort1(a,left,right);int keyi = PartSort2(a, left, right);//int keyi = PartSort3(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);
}

6.3 前后指针法

6.3.1动图展示

6.3.2代码实现

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{//三数取中int keyi = Getmid(a, left, right);Swap(&a[keyi], &a[left]);keyi = left;int prev = left;int cur = prev+1;while (cur <= right){if (a[cur] < a[keyi]&&cur!=++prev){Swap(&a[cur], &a[prev]);}cur++;}Swap(&a[prev], &a[keyi]);return prev;
}
void QuickSort(int* a, int left, int right)
{if (left >= right){return;}//优化小区间if (right - left + 1 < 10){InsertSort(a + left, right - left + 1);return;}//int keyi = PartSort1(a,left,right);//int keyi = PartSort2(a, left, right);int keyi = PartSort3(a, left, right);QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);
}

6.4快速排序非递归实现 

// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{Stack st;STInit(&st);STPush(&st, right);STPush(&st, left);while (!STEmpty(&st)){int begin = STTop(&st);STPop(&st);int end = STTop(&st);STPop(&st);int keyi = PartSort3(a, begin, end);if(end>keyi+1){STPush(&st, end);STPush(&st, keyi + 1);}if(begin<keyi-1){STPush(&st, keyi - 1);STPush(&st, begin);}}STDestroy(&st);
}

快速排序优化

  1. 三数取中法选key
  2. 递归到小的子区间时,可以考虑使用插入排序 

这两步在上述代码中都有所体现

快速排序的特性总结:

  1. 快速排序整体的综合性能和使用场景都是比较好的,所以才敢叫快速排序
  2. 时间复杂度:O(N*logN)
  3. 空间复杂度:O(logN)
  4. 稳定性:不稳定 

7.归并排序

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

7.1动图展示

7.2代码实现

7.2.1递归实现

void _MergeSort(int* a, int* tmp, int begin, int end)
{//递归停止条件if (begin >= end){return;}int mid = (begin + end) / 2;int begin1 = begin;int end1 = mid;int begin2 = mid + 1;int end2 = end;//子问题_MergeSort(a, tmp, begin1, end1);_MergeSort(a, tmp, begin2, end2);//当前问题//升序int i = begin;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){tmp[i++] = a[begin1++];}else {tmp[i++] = a[begin2++];}}while (begin1 <= end1){tmp[i++] = a[begin1++];}while (begin2 <= end2){tmp[i++] = a[begin2++];}memcpy(a + begin, tmp + begin, sizeof(int) * (end-begin+1));
}
void MergeSort(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}_MergeSort(a, tmp, 0, n-1);free(tmp);tmp = NULL;
}

7.2.2非递归实现

// 归并排序非递归实现
void MergeSortNonR(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}int gap = 1;while (gap < n){int i;for (i = 0; i < n; i += 2 * gap){int begin1 = i;int end1 = i + gap-1;int begin2 = i + gap;int end2 = i + 2 * gap-1;int j = i;// 第二组都越界不存在,这一组就不需要归并if (begin2 >= n)break;// 第二的组begin2没越界,end2越界了,需要修正一下,继续归并if (end2 >= n)end2 = n - 1;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, tmp, n * sizeof(int));gap *= 2;}free(tmp);tmp = NULL;
}

归并排序的特性总结:

  1. 归并的缺点在于需要O(N)的空间复杂度,归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度:O(N*logN)
  3. 空间复杂度:O(N)
  4. 稳定性:稳定 

8.计数排序

计数排序又称为鸽巢原理,是对哈希直接定址法的变形应用。 

操作步骤:

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中   

8.1动图展示

 

8.2代码实现

void CountSort(int* a, int n)
{int max;int min;max = min = a[0];for (int i = 1; i < n; i++){if (a[i] > max){max = a[i];}if (a[i] < min){min = a[i];}}int range = max - min + 1;int* count = (int*)calloc(range, sizeof(int));for (int i = 0; i < n; i++){count[a[i] - min]++;}int j = 0;for (int i = 0; i < range; i++){while (count[i]--){a[j++] = i + min;}}free(count);count = NULL;
}

计数排序的特性总结:

  1. 计数排序在数据范围集中时,效率很高,但是适用范围及场景有限。
  2. 时间复杂度:O(MAX(N,范围))
  3. 空间复杂度:O(范围)

9.排序算法复杂度计稳定性总结 

 

 注意:这里的稳定性是指:指数组中相同元素在排序后相对位置不发生变化。

也就是原先一样大的数在排序后的相对位置不改变 

---------------------------------------------------------------------------------------------------------------------------------

本次讲解到此结束,喜欢的小伙伴们记得点赞收藏哦~ 

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

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

相关文章

快手可灵视频生成大模型全方位测评

快手视频生成大模型“可灵”&#xff08;Kling&#xff09;&#xff0c;是全球首个真正用户可用的视频生成大模型&#xff0c;自面世以来&#xff0c;凭借其无与伦比的视频生成效果&#xff0c;在全球范围内赢得了用户的热烈追捧与高度评价。截至目前&#xff0c;申请体验其内测…

人工智能:大语言模型提示注入攻击安全风险分析报告下载

大语言模型提示注入攻击安全风险分析报告下载 今天分享的是人工智能AI研究报告&#xff1a;《大语言模型提示注入攻击安全风险分析报告》。&#xff08;报告出品方&#xff1a;大数据协同安全技术国家工程研究中心安全大脑国家新一代人工智能开放创新平台&#xff09; 研究报告…

stats 监控 macOS 系统

Stats 监控 macOS 系统 CPU 利用率GPU 利用率内存使用情况磁盘利用率网络使用情况电池电量 brew install stats参考 stats github

如何在 Debian 8 上安装和使用 PostgreSQL 9.4

前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站。 简介 关系型数据库是满足多种需求的数据组织的基石。它们支持从在线购物到火箭发射等各种应用。PostgreSQL 是一种历史悠久但仍然活跃的…

深入理解PHP中的异常处理与错误日志记录

引言 在PHP开发中&#xff0c;异常处理和错误日志记录是确保应用稳定性和可维护性的重要环节。正确地处理异常和记录错误不仅能帮助开发者快速定位问题&#xff0c;还能提升用户体验。本文将深入探讨PHP中的异常处理机制&#xff0c;并通过代码案例展示如何有效地记录错误日志…

59、mysql存储过程

存储过程 一、存储过程&#xff1a; 1.1、存储过程的概念 概念&#xff1a;完成特定功能的sql语句的集合。把定义好的sql集合在一个特定的sql的函数当中 每次执行调用函数即可。还可以实现传参的调用。 1.2、存储过程的语法&#xff1a; delimiter $$ ##delimiter开始和结…

支持4K高分辨率,PixArt-Sigma最新文生图落地经验

PixArt-Sigma是由华为诺亚方舟实验室、大连理工大学和香港大学的研究人员共同开发的一个先进的文本到图像&#xff08;Text-to-Image&#xff0c;T2I&#xff09;生成模型。 PixArt-Sigma是在PixArt-alpha的基础上进一步改进的模型&#xff0c;旨在生成高质量的4K分辨率图像。…

2024牛客暑期多校第四场

A-LCT 带权并查集&#xff0c;维护一下每个点在当前树的深度和以它为根能找到的最深的深度。‘ #include<bits/stdc.h>using namespace std; typedef long long ll; const int N 1e6 100;int fa[N],ans[N],val[N];int find(int x){if(fa[x]x)return x;int tfa[x];fa[x…

Spring系统学习-基于XML的声明式事务

基本概念 在Spring框架中&#xff0c;基于XML的事务管理是一种通过XML配置文件来管理事务的方式。Spring提供了强大的事务管理功能&#xff0c;可以与多种持久化技术&#xff08;如JDBC、Hibernate、JPA等&#xff09;结合使用。以下是如何在Spring中使用基于XML的事务管理的基…

C++初学(3)

面向对象编程&#xff08;OOP&#xff09;的本质是设计并拓展自己的数据类型&#xff0c;设计自己的数据类型就是让类型与数据匹配。内置的C类型分为两组&#xff1a;基本类型和复合类型。这里我们将介绍基本类型的整数和浮点数 3.1、简单变量 3.1.1、变量名 C必须遵循几种简…

场外期权如何报价?名义本金是什么?

今天带你了解场外期权如何报价&#xff1f;名义本金是什么&#xff1f;投资者首先需要挑选自己想要进行期权交易的沪深上市公司股票。选出股票后&#xff0c;需要将股票信息、预期的操作时间&#xff08;如期限&#xff09;、看涨或看跌的选择以及预计的交易金额等信息报给场外…

计算机网络(四)数字签名和CA认证

什么是数字签名和CA认证&#xff1f; 数字签名 数字签名的过程通常涉及以下几个步骤&#xff1a; 信息哈希&#xff1a;首先&#xff0c;发送方使用一个哈希函数&#xff08;如SHA-256&#xff09;对要发送的信息&#xff08;如电子邮件、文件等&#xff09;生成一个固定长度…

全链路追踪 性能监控,GO 应用可观测全面升级

作者&#xff1a;古琦 01 介绍 随着 Kubernetes 和容器化技术的普及&#xff0c;Go 语言不仅在云原生基础组件领域广泛应用&#xff0c;也在各类业务场景中占据了重要地位。如今&#xff0c;越来越多的新兴业务选择 Golang 作为首选编程语言。得益于丰富的 RPC 框架&#xff…

Golang实现Word模板内容填充导出

这里我们使用一个广泛使用且免费处理 .docx 文件的库&#xff0c;github.com/nguyenthenguyen/docx. 安装 github.com/nguyenthenguyen/docx 库 首先&#xff0c;确保你已经安装了 docx 库&#xff1a; go get github.com/nguyenthenguyen/docx使用 docx 库处理 Word 模板 …

调用@WebService接口时,应该将他如何注入到类里

在Java中&#xff0c;使用WebService注解时&#xff0c;我们常常需要通过依赖注入的方式将Web服务客户端注入到我们的类中。这里有几种常见的方法来实现这一点。 ### 方法一&#xff1a;使用WebServiceRef WebServiceRef注解用于注入Web服务的引用。它通常用于在客户端类中声…

探索未来IT趋势:塑造数字时代的五大关键技术

在这个日新月异的数字时代&#xff0c;信息技术&#xff08;IT&#xff09;不仅深刻改变了我们的生活方式&#xff0c;还推动了全球经济的飞速发展。随着新技术的不断涌现&#xff0c;IT领域正以前所未有的速度进化。今天&#xff0c;让我们一同探索那些正在塑造未来数字世界的…

【Ubuntu】Ubuntu 配置镜像源(ARM)

【Ubuntu】Ubuntu 配置镜像源&#xff08;ARM&#xff09; 零、起因 最近在QEMU中安装了个ubuntu-24.04-live-server-arm64&#xff0c;默认是国外的软件源&#xff0c;很慢&#xff0c;故替换到国内。 壹、替换 源地址&#xff08;清华源&#xff09; https://mirror.tun…

ubuntu实践

目录 扩容 本机上ping不通新建立的虚拟机 ssh连接 装sshd ssh客户端版本较低&#xff0c;会报key exchange算法不匹配问题 ubuntun上装docker 将centos7下的安装包改造成适配 ubuntu的包 参考文章 扩容 Hyper-V 管理器安装的ubutun扩容磁盘空间说明_hype-v磁盘扩容-…

复现open-mmlab的mmsegmentation详细细节

复现open-mmlab的mmsegmentation详细细节 1.配置环境2.数据处理3.训练 1.配置环境 stage1&#xff1a;创建python环境 conda create --name openmmlab python3.8 -y conda activate openmmlabstage2&#xff1a;安装pytorch&#xff08;这里我是以torch1.10.0为例&#xff09…

VINS-Fusion 回环检测pose_graph_node

VINS-Fusion回环检测,在节点pose_graph_node中启动。 pose_graph_node总体流程如下: 重点看process线程。 process线程中,将订阅的图像、点云、位姿时间戳对齐,对齐后分别存入image_msg、point_msg、pose_msg。pose_msg为VIO后端优化发布的位姿。 一、创建关键帧keyFram…