常见排序（C语言版）

1.排序的概念及其应用

1.1排序的概念

排序：​ 在计算机科学与数学中，一个排序算法（英语：Sorting algorithm）是一种能将一串资料依照特定排序方式排列的算法。

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i] = r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。

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

外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不断地在内外存之间移动数据的排序。

排序的常见方法：插入、交换、选择、合并等等。

1.2排序的应用

排序在生活中无处不在，比如购物时对价格筛选、销量筛选等都用到排序，游戏中各个英雄的国服榜单等。排序算法也用在处理文字资料以及产生人类可读的输出结果。

注：虽然排序算法是一个简单的问题，但是从计算机科学发展以来，在此问题上已经有大量的研究。举例而言，冒泡排序在1956年就已经被研究。虽然大部分人认为这是一个已经被解决的问题，有用的新算法仍在不断的被发明。（例子：图书馆排序在2004年被发表）。

1.3常见的排序算法

2.常见排序算法实现

2.1插入排序

2.1.1基本思想

直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的数据按值的大小逐个插入到一个已经排好序的有序序列中，直到所有的数据插入完为止，得到一个新的有序序列。

类似于平时玩的扑克牌的思想（摸牌的时候，摸一张就插入之前已经排好的序列中）

2.1.2直接插入排序

当插入第i（i >= 1）个元素时，前面的array[0]，array[1]，……，array[i-1]已经排好序，此时用array[i]的排序码与array[i-1]，array[i-2]……的排序码进行比较，找到插入位置即将array[i]插入，原位置上的元素顺序后移。

特点：

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

2.1.3直接插入排序代码实现

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--;}elsebreak;}a[end+1] = tmp;}
}

2.1.4希尔排序（缩小增量排序）

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

特点： 

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在很多书中给出的希尔排序的时间复杂度都不固定：
  4. 稳定性：不稳定

 2.1.5希尔排序代码实现

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 (tmp < a[end]){a[end + gap] = a[end];end -= gap;}elsebreak;}a[end + gap] = tmp;}}}

2.2选择排序

2.2.1基本思想

每一次从待排的数据元素中选出最小（或者最大）的一个元素，存放在序列的起始位置，知道全部待排元素的数据元素排完。

2.2.2直接选择排序

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

 特点：

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

 2.2.3直接选择排序代码实现

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

注：代码实现的是同时选择最大和最小的数据元素，然后分别和数组尾部和头部交换

 2.2.4堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。（ps:堆排序在写树中的二叉树部分的应用有讲解，树）

​

 特点：

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

2.3交换排序

2.3.1基本思想

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排
序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。 ​

2.3.2冒泡排序代码实现

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

​ 2.3.3快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非像，在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。将区间按照基准值划分为左右两半部分的常见方式有：

  1. hoare版本：
    ​
  2. 挖坑法：
  3. 前后指针版本：

 快速排序特点：

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

注：在hoare版本中，选取key的时候，需要注意选左边做key，要让右边先走；右边做key，要让左边先走 ，这样才能保证交换key和相遇点的时候不会出现顺序混乱的情况。具体原因如下：

2.3.4快速排序优化

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

2.3.5快速排序非递归

 在数据量很大的时候，递归可能会有栈溢出的风险，并且速度也有所减慢，因此可以在原有的基础上加以改进，改为非递归。在递归的时候，递归主要就是存储对应的区间对应的下标，因为执行的语句都是相同的，就是分割不同的区间，传递不同的参数，所以可以用一个类似于后递归先处理的这样的逻辑的数据结构来存储对应的下标，没错，就是栈，每次入栈的时候，将要分割的区间对应的下标入栈（区间是两个下标，就一次性入两个，出两个），出栈即可。

2.3.6快速排序代码实现：

int GetMid(int* a,int left,int right)
{int midi = (left + right) / 2;if (a[left] < a[midi]){// left midi rightif (a[midi] < a[right]){return midi;}// left right midi else if (a[left] < a[right]){return right;}// right left midielsereturn left;}if (a[left] > a[midi]){// right midi leftif (a[midi] > a[right]){return midi;}// midi right leftelse if (a[right] < a[left]){return right;}//midi left rightelsereturn left;}
}
int QSortPart1(int* a,int left,int right)
{//三数取中-->取合适的keyint midi = GetMid(a, left, right);Swap(&a[left], &a[midi]);int keyi = left;int start = left;int end = right;while (start < end){//左边找小while (a[end] >= a[keyi] && start < end){end--;}//右边找大while (a[start] <= a[keyi] && start < end){start++;}Swap(&a[start], &a[end]);}Swap(&a[start], &a[keyi]);return start;
}
//前后指针
int QSortPart2(int* a, int left, int right)
{int keyi = left;int prev = left;int cur = left + 1;while(cur <= right){if (a[cur] < a[keyi] && a[cur] != a[++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);}else{int keyi = QSortPart1(a, left, right);//int keyi = QSortPart2(a, left, right);//[left , keyi-1]  keyi  [key+1,right]QuickSort(a, left, keyi - 1);QuickSort(a, keyi + 1, right);}
}
//非递归快速排序
void QuickSortNonR(int* a, int left, int right)
{ST tmp;StackInit(&tmp);StackPush(&tmp, right);StackPush(&tmp, left);while(!StackEmpty(&tmp)){int start = StackTop(&tmp);StackPop(&tmp);int end = StackTop(&tmp);StackPop(&tmp);int keyi = QSortPart1(a, start, end);//[left , keyi-1]  keyi  [key+1,right]if (keyi + 1 < end){StackPush(&tmp, end);StackPush(&tmp, keyi + 1);}if (start < keyi - 1){StackPush(&tmp, keyi - 1);StackPush(&tmp, start);}}StackDestroy(&tmp);
}

2.4归并排序

2.4.1基本思想

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

注：在划分区间的时候，要特别注意下面的情况

特点：

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

2.4.2归并排序非递归

归并排序递归采用的是分割成两个有序的子区间，然后再合并，是在递归返回的过程中有序，所以在用非递归实现的时候，如果用栈模拟，那就需要用两个栈存放两个子区间的下标，然后再出栈，比较等。但是，采用两层循环就能很好地解决问题，将数据同样的分为n / gap组，每组gap个数据，然后两两合并，特别注意控制好分割的时候会不会越界即可。

 2.4.3归并排序代码实现

void _MergeSort(int* a, int* tmp, int start, int end)
{if (start >= end)return;int midi = (start + end) / 2;//[start1,midi] [midi+1,end1]_MergeSort(a, tmp, start, midi);_MergeSort(a, tmp, midi + 1, end);int start1 = start, end1 = midi;int start2 = midi + 1, end2 = end;int i = start;while (start1 <= end1 && start2 <= end2){tmp[i++] = a[start1] < a[start2] ? a[start1++] : a[start2++];}//处理一边比较小全部进完，另一边还没有进完的情况while (start1 <= end1){tmp[i++] = a[start1++];}while (start2 <= end2){tmp[i++] = a[start2++];}memcpy(a+start, tmp+start, (end-start+1)*sizeof(int));
}
void MergeSort(int* a, int n)
{int start = 0, end = n - 1;int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}_MergeSort(a, tmp, 0, n-1);free(tmp);	tmp = NULL;
}//归并排序非递归
void MergeSortNonR(int* a, int n)
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}//gap是每组数据个数int gap = 1;while(gap<n){//i是每组归并的起点for (int i = 0; i < n; i += 2 * gap){int start1 = i, end1 = i + gap - 1;int start2 = i + gap, end2 = i + 2 * gap - 1;int j = i;if (end1 > n-1 || start2 > n-1){break;}if (end2 > n - 1){end2 = n - 1;}while (start1 <= end1 && start2 <= end2){tmp[j++] = a[start1] < a[start2] ? a[start1++] : a[start2++];}//处理一边比较小全部进完，另一边还没有进完的情况while (start1 <= end1){tmp[j++] = a[start1++];}while (start2 <= end2){tmp[j++] = a[start2++];}memcpy(a + i, tmp + i, (end2 - i + 1) * sizeof(int));}gap *= 2;}free(tmp);tmp = NULL;
}

2.5非比较排序

2.5.1基本思想

计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

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

 特点：

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

 2.5.2计数排序代码实现

void CountSort(int* a, int n)
{//找出数组最大最小，确定范围int min = a[0];int max = a[0];for (int i = 1; i < n; i++){if (a[i] < min){min = a[i];}if (a[i] > max){max = a[i];}}int range = max - min + 1;int* count = (int*)calloc(range, sizeof(int));if (count == NULL){perror("calloc fail");return;}//count数组与a数组映射的相对位置的下标++for (int j = 0; j < n; j++){count[a[j] - min]++;}//回到原数组int k = 0;for (int l = 0; l < range; l++){while (count[l]--){a[k++] = l + min;}}
}

 

3.排序算法复杂度及稳定性分析 

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

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

相关文章

聚观早报 | 小米三折叠手机专利曝光；李斌谈合肥投资蔚来

聚观早报 | 小米三折叠手机专利曝光；李斌谈合肥投资蔚来

聚观早报每日整理最值得关注的行业重点事件&#xff0c;帮助大家及时了解最新行业动态&#xff0c;每日读报&#xff0c;就读聚观365资讯简报。 整理丨Cutie 9月20日消息 小米三折叠手机专利曝光 李斌谈合肥投资蔚来 索尼PS5 Pro包装亮相 新一代Spectacles AR眼镜发布 通…
阅读更多...
《AI系统：原理与架构》于华为HC大会2024正式发布

《AI系统：原理与架构》于华为HC大会2024正式发布

2024年9月21日&#xff0c;《AI系统&#xff1a;原理与架构》新书发布会在上海世博馆华为HC大会顺利举办。本书由华为昇腾技术专家、B站AI科普博主ZOMI酱和哈工大软件学院副院长苏统华教授联合编写&#xff0c;是领域内AI系统方面填补空白的重磅之作。 发布会上&#xff0c;《A…
阅读更多...
Spring：项目中的统一异常处理和自定义异常

Spring：项目中的统一异常处理和自定义异常

介绍异常的处理方式。在项目中&#xff0c;都会进行自定义异常&#xff0c;并且都是需要配合统一结果返回进行使用。 1.背景引入 &#xff08;1&#xff09;背景介绍 为什么要处理异常&#xff1f;如果不处理项目中的异常信息&#xff0c;前端访问我们后端就是显示访问失败的…
阅读更多...
JavaScript发送邮件：实现前端触发的教程？

JavaScript发送邮件：实现前端触发的教程？

JavaScript发送邮件的方式&#xff1f;怎么使用JavaScript发信&#xff1f; 无论是用户反馈、联系表单还是自动通知&#xff0c;前端触发的邮件发送功能都能极大地提升用户体验。AokSend将详细介绍如何通过JavaScript发送邮件&#xff0c;实现前端触发的邮件发送功能。 JavaS…
阅读更多...
跨站请求伪造(CSRF)漏洞详解

跨站请求伪造(CSRF)漏洞详解

免责申明 本文仅是用于学习检测自己搭建的DVWA靶场环境有关CSRF的原理和攻击实验，请勿用在非法途径上，若将其用于非法目的，所造成的一切后果由您自行承担，产生的一切风险和后果与笔者无关；本文开始前请认真详细学习《‌中华人民共和国网络安全法》‌及其所在国家地区相关法…
阅读更多...
ubuntu24安装vivado24（安装并解决若干错误）

ubuntu24安装vivado24（安装并解决若干错误）

目录 安装方法&#xff1a;问题1&#xff1a;解决办法&#xff1a; 问题2&#xff1a;解决方法&#xff1a; 安装完成&#xff1a; 安装方法&#xff1a; 注意&#xff1a;内存最好预留80G空闲的。 安装好大小&#xff1a; 安装依赖库&#xff1a; sudo apt-get update sud…
阅读更多...
计算机网络17——IM聊天系统——客户端核心处理类框架搭建

计算机网络17——IM聊天系统——客户端核心处理类框架搭建

目的 拆开客户端和服务端&#xff0c;使用Qt实现客户端&#xff0c;VS实现服务端 Qt创建项目 Qt文件类型 .pro文件&#xff1a;配置文件&#xff0c;决定了哪些文件参与编译&#xff0c;怎样参与编译 .h .cpp .ui&#xff1a;画图文件 Qt编码方式 Qt使用utf-8作为编码方…
阅读更多...
鸿蒙 WebView 如何 Debug

鸿蒙 WebView 如何 Debug

前置&#xff1a; hdc chrome //----------------------------------------------------------------------------------------------- hdc shell cat /proc/net/unix | grep devtools 0: 00000002 0 10000 1 1 81134005 webview_devtools_remote_62479exit执行&…
阅读更多...
vulnhub（12）：bob 1.0.1（gpg文件解密）

vulnhub（12）：bob 1.0.1（gpg文件解密）

端口 nmap主机发现 nmap -sn 192.168.72.0/24 ​ Nmap scan report for 192.168.72.169 Host is up (0.00020s latency). ​ 169是新出现的机器&#xff0c;他就是靶机 nmap端口扫描 nmap -Pn -sV 192.168.72.169 -p- --min-rate 10000 -oA nmap/scan 扫描开放端口保存到 nmap…
阅读更多...
STL简介

STL简介

在了解了C中的类和对象以及内存管理基本的知识后接下来我们将进入STL的学习&#xff0c;在此我们在本篇会先了解STL的由来以及大致了解STL的组成&#xff0c;接下来在之后的篇章中我将依次来学string、vector等&#xff0c;学习完STL之后相信你会进一步了解C的魅力所在。接下来…
阅读更多...
后台数据管理系统 - 项目架构设计-Vue3+axios+Element-plus（0917）

后台数据管理系统 - 项目架构设计-Vue3+axios+Element-plus（0917）

七、引入 element-ui 组件库 我的Git仓库&#xff1a;https://gitee.com/msyycn/vue3-hei-ma.git 官方文档&#xff1a; https://element-plus.org/zh-CN/ 安装 $ pnpm add element-plus自动按需&#xff1a; 安装插件 pnpm add -D unplugin-vue-components unplugin-auto…
阅读更多...
机器翻译之Bahdanau注意力机制在Seq2Seq中的应用

机器翻译之Bahdanau注意力机制在Seq2Seq中的应用

目录 1.创建 添加了Bahdanau的decoder 2. 训练 3.定义评估函数BLEU 4.预测 5.知识点个人理解 1.创建 添加了Bahdanau的decoder import torch from torch import nn import dltools#定义注意力解码器基类 class AttentionDecoder(dltools.Decoder): #继承dltools.Decoder写…
阅读更多...
元学习的简单示例

元学习的简单示例

代码功能 模型结构&#xff1a;SimpleModel是一个简单的两层全连接神经网络。 元学习过程&#xff1a;在maml_train函数中&#xff0c;每个任务由支持集和查询集组成。模型先在支持集上进行训练&#xff0c;然后在查询集上进行评估&#xff0c;更新元模型参数。 任务生成&…
阅读更多...
3DMAX乐高积木插件LegoBlocks使用方法

3DMAX乐高积木插件LegoBlocks使用方法

3DMAX乐高积木插件LegoBlocks&#xff0c;用户可以通过控件调整和自定义每个乐高积木的外观和大小。 【适用版本】 3dMax2009或更高版本&#xff08;不仅限于此范围&#xff09; 【安装方法】 3DMAX乐高积木插件无需安装&#xff0c;使用时直接拖动插件脚本文件到3dMax视口中…
阅读更多...
NLP 主要语言模型分类

NLP 主要语言模型分类

文章目录 ngram自回归语言模型TransformerGPTBERT&#xff08;2018年提出&#xff09;基于 Transformer 架构的预训练模型特点应用基于 transformer&#xff08;2017年提出&#xff0c;attention is all you need&#xff09;堆叠层数与原transformer 的差异bert transformer 层…
阅读更多...
Packet Tracer - 配置编号的标准 IPv4 ACL(两篇)

Packet Tracer - 配置编号的标准 IPv4 ACL(两篇)

Packet Tracer - 配置编号的标准 IPv4 ACL(第一篇) 目标 第 1 部分&#xff1a;计划 ACL 实施 第 2 部分&#xff1a;配置、应用和验证标准 ACL 背景/场景 标准访问控制列表 (ACL) 为路由器 配置脚本&#xff0c;基于源地址控制路由器 是允许还是拒绝数据包。本练习的主要内…
阅读更多...
leetcode练习 二叉树的最大深度

leetcode练习 二叉树的最大深度

给定一个二叉树 root &#xff0c;返回其最大深度。 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。 示例 1&#xff1a; 输入&#xff1a;root [3,9,20,null,null,15,7] 输出&#xff1a;3提示&#xff1a; 树中节点的数量在 [0, 104] 区间内。-100 …
阅读更多...
python学习第十节：爬虫基于requests库的方法

python学习第十节：爬虫基于requests库的方法

python学习第十节&#xff1a;爬虫基于requests库的方法 requests模块的作用&#xff1a; 发送http请求&#xff0c;获取响应数据&#xff0c;requests 库是一个原生的 HTTP 库&#xff0c;比 urllib 库更为容易使用。requests 库发送原生的 HTTP 1.1 请求&#xff0c;无需手动…
阅读更多...
Linux：login shell和non-login shell以及其配置文件

Linux：login shell和non-login shell以及其配置文件

相关阅读 Linuxhttps://blog.csdn.net/weixin_45791458/category_12234591.html?spm1001.2014.3001.5482 shell是Linux与外界交互的程序&#xff0c;登录shell有两种方式&#xff0c;login shell与non-login shell&#xff0c;它们的区别是读取的配置文件不同&#xff0c;本…
阅读更多...
NPM如何切换淘宝镜像进行加速

NPM如何切换淘宝镜像进行加速

什么是淘宝镜像NPM&#xff1f; 淘宝镜像NPM和官方NPM的主要区别在于服务器的地理位置和网络访问速度。淘宝镜像NPM是由淘宝团队维护的一个npm镜像源&#xff0c;主要服务于中国大陆用户&#xff0c;提供了一个国内的npm镜像源&#xff0c;地址为 https://registry.npmmirror.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023