排序【七大排序】

文章目录

  • 1. 排序的概念及引用
    • 1.1 排序的概念
    • 1.2 常见的排序算法
  • 2. 常见排序算法的实现
    • 2.1 插入排序
      • 2.1.1基本思想：
      • 2.1.2 直接插入排序
      • 2.1.3 希尔排序( 缩小增量排序 )
    • 2.2 选择排序
      • 2.2.1基本思想：
      • 2.2.2 直接选择排序:
      • 2.2.3 堆排序
    • 2.3 交换排序
      • 2.3.1冒泡排序
      • 2.3.2 快速排序
    • 2.4 归并排序
      • 2.4.1 基本思想
      • 2.4.2 海量数据的排序问题
  • 3. 排序算法复杂度及稳定性分析

1. 排序的概念及引用

1.1 排序的概念

排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持
不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
在这里插入图片描述
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

1.2 常见的排序算法

在这里插入图片描述

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]插入，原来位置上的元素顺序后移

代码实现

public static void insertSort(int[] array){for (int i = 1; i < array.length; i++) {int tmp = array[i];int j = i-1;for (; j >= 0; j--) {if(array[j] > tmp){array[j+1] = array[j];}else{break;}}array[j+1] = tmp;}}

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

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

2.1.3 希尔排序( 缩小增量排序 )

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成多个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
在这里插入图片描述
代码实现

 public static void hillSort(int[] array){int gap = array.length;while(gap > 1){gap/=2;hill(array,gap);}}public static void hill(int[] array,int gap){for (int i = gap; i < array.length; i++) {int tmp = array[i];int j = i - gap;for (; j >= 0 ; j-=gap) {if(array[j] > tmp){array[j+gap] = array[j];}else {break;}}array[j+gap] = tmp;}}

希尔排序的特性总结：

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

2.2 选择排序

2.2.1基本思想：

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

2.2.2 直接选择排序:

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

代码实现：
代码一：

public static void selectSort(int[] array){for (int i = 0; i < array.length; i++) {int min = i;for (int j = i+1; j < array.length; j++) {if(array[j] < array[min]){min = j;}}swap(array,min,i);}}public static void swap(int[] array,int i,int j){int tmp = array[i];array[i] = array[j];array[j] = tmp;}

代码二：

public static void selectSort1(int[] array){int left = 0;int right = array.length-1;while(left < right){int max = left;int min = left;for (int j = left+1; j <= right; j++) {if(array[j] < array[min]){min = j;}if(array[j] > array[max]){max = j;}}swap(array,min,left);if(left == max){max = min;}swap(array,max,right);left++;right--;}}public static void swap(int[] array,int i,int j){int tmp = array[i];array[i] = array[j];array[j] = tmp;}

【直接选择排序的特性总结】

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

2.2.3 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
在这里插入图片描述
代码实现：

public static void heapSort(int[] array){int end = array.length-1;createHeap(array);while(end > 0){swap(array,0,end);siftDown(array,0,end);end--;}}
public static void createHeap(int[] array){for (int i = (array.length-1-1)/2; i >= 0; i--) {siftDown(array,i,array.length);}}private static void siftDown(int[] array, int parent, int length) {int child = parent*2 + 1;while(child < length){if(child+1 < length && array[child] < array[child+1]){child++;}if(array[child] > array[parent]){swap(array,child,parent);parent = child;child = child*2 +1;}else{break;}}}

【堆排序的特性总结】

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

2.3 交换排序

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

2.3.1冒泡排序

代码实现：

public static void bubbleSort(int[] array){for (int i = 0; i < array.length-1; i++) {boolean flg = false;for (int j = 0; j < array.length-1-i; j++) {if(array[j] > array[j+1]){swap(array,j,j+1);flg = true;}}if(!flg){break;}}}

【冒泡排序的特性总结】

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

2.3.2 快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

代码实现：

public static void quickSort(int[] array){quick(array,0,array.length-1);}public static void quick(int[] array,int start,int end){if(start >= end){return;}int mid= midIndex(array,start,end);swap(array,mid,start);int quickIndex = quickationHole(array,start,end);quick(array,start,quickIndex-1);quick(array,quickIndex+1,end);}public static int quickation(int[] array,int left ,int right){int tmp = left;while(left < right){while(left < right && array[right] >= array[tmp]){right--;}while(left< right && array[left] <= array[tmp]){left++;}swap(array,left, right);}swap(array,left,tmp);return left;}public static int quickationHole(int[] array,int left,int right){int tmp = array[left];while(left < right){while(left < right && array[right] >= tmp){right--;}array[left] = array[right];while(left < right && array[left] <= tmp){left++;}array[right] = array[left];}array[left] = tmp;return right;}public static int midIndex(int[] array,int start,int end){int mid = (start + end)>>>2;if(array[start] < array[end]){if(array[mid] > array[start]){return start;}else if (array[end] < array[mid]){return end;}else {return mid;}}else{if(array[mid] > array[start]){return end;}else if (array[end] < array[mid]){return start;}else {return mid;}}}

非递归实现：

public static void quickSortNor(int[] array){int start = 0;int end = array.length-1;Stack<Integer> stack = new Stack<>();int quickIndex = quickationHole(array,start,end);if(start+1 < quickIndex){stack.push(start);stack.push(quickIndex-1);}if(quickIndex+1 < end){stack.push(quickIndex+1);stack.push(end);}while(!stack.empty()){end = stack.pop();start = stack.pop();quickIndex = quickationHole(array,start,end);if(start+1 < quickIndex){stack.push(start);stack.push(quickIndex-1);}if(quickIndex+1 < end){stack.push(quickIndex+1);stack.push(end);}}}public static int quickationHole(int[] array,int left,int right){int tmp = array[left];while(left < right){while(left < right && array[right] >= tmp){right--;}array[left] = array[right];while(left < right && array[left] <= tmp){left++;}array[right] = array[left];}array[left] = tmp;return right;}

【快速排序总结】

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

  2. 时间复杂度：O(N*logN)
    在这里插入图片描述

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

  4. 稳定性：不稳定

2.4 归并排序

2.4.1 基本思想

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

public static void mergeSort(int[] array){mergeSortFun(array,0,array.length-1);}private static void mergeSortFun(int[] array, int left, int right) {if(left >= right){return;}int mid = (left + right)/2;mergeSortFun(array,left,mid);mergeSortFun(array,mid+1,right);merge(array,left,mid,right);}private static void merge(int[] array,int left,int mid,int right){int s1 = left;int e1 = mid;int s2 = mid+1;int e2 = right;int[] tmparr = new int[right-left+1];int k =0;while(s1 <= e1 && s2 <= e2){if(array[s1] <= array[s2]){tmparr[k++] = array[s1++];}else{tmparr[k++] = array[s2++];}}while(s1 <= e1){tmparr[k++] = array[s1++];}while (s2 <= e2){tmparr[k++] = array[s2++];}for (int i = 0; i < tmparr.length; i++) {array[left+i] = tmparr[i];}}

非递归先实现：

public static void mergeSortNor(int[] array){int gap = 1;while(gap < array.length){for(int i = 0;i < array.length;i= i+gap*2){int left = i;int mid = left + gap -1;int right = mid + gap;if(mid >= array.length){mid = array.length-1;}if (right >= array.length) {right = array.length-1;}merge(array,left,mid,right);}gap*=2;}}private static void merge(int[] array,int left,int mid,int right){int s1 = left;int e1 = mid;int s2 = mid+1;int e2 = right;int[] tmparr = new int[right-left+1];int k =0;while(s1 <= e1 && s2 <= e2){if(array[s1] <= array[s2]){tmparr[k++] = array[s1++];}else{tmparr[k++] = array[s2++];}}while(s1 <= e1){tmparr[k++] = array[s1++];}while (s2 <= e2){tmparr[k++] = array[s2++];}for (int i = 0; i < tmparr.length; i++) {array[left+i] = tmparr[i];}}

【归并排序总结】

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

2.4.2 海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

  1. 先把文件切分成 200 份，每个 512 M
  2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
  3. 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

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

在这里插入图片描述
在这里插入图片描述

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

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

相关文章

极品三国新手攻略之进阶篇

极品三国新手攻略之进阶篇

尊敬的主公大人您好&#xff0c;首先恭喜您在游戏中取得的不俗成绩&#xff0c;相信您已经熟练掌握了不少玩法。今天&#xff0c;我们给大家奉上一份极品三国新手攻略之进阶篇&#xff0c;希望能为您提供有力的帮助。本篇攻略将为您深入分析游戏中武将、装备、试炼塔以及神兵等…
阅读更多...
新版pycharm(2023.2.2)修改字体大小

新版pycharm(2023.2.2)修改字体大小

下载了2023新版pycharm&#xff0c;想修改字体&#xff0c;发现找不到之前的setting入口&#xff0c;网上搜索也都是file-setting-editor这些&#xff0c;自己找了找&#xff0c;记录下 2023版pycharm的修改字体大小在file-Manage IDE Settings-Setting Sync… 里面&#xff0…
阅读更多...
python+django高校体育乒乓球场地预约管理系统_s2409

python+django高校体育乒乓球场地预约管理系统_s2409

本系统提供给管理员对首页&#xff0c;个人中心&#xff0c;用户管理&#xff0c;乒乓球场管理,场地类型管理,场地预约管理,暂离申请管理,离开申请管理,管理员管理,留言反馈,系统管理等诸多功能进行管理。本系统对于用户输入的任何信息都进行了一定的验证&#xff0c;为管理员操…
阅读更多...
基于蜜獾优化的BP神经网络（分类应用） - 附代码

基于蜜獾优化的BP神经网络（分类应用） - 附代码

基于蜜獾优化的BP神经网络&#xff08;分类应用&#xff09; - 附代码 文章目录 基于蜜獾优化的BP神经网络&#xff08;分类应用&#xff09; - 附代码1.鸢尾花iris数据介绍2.数据集整理3.蜜獾优化BP神经网络3.1 BP神经网络参数设置3.2 蜜獾算法应用 4.测试结果&#xff1a;5.M…
阅读更多...
C# 图解教程 第5版 —— 第5章 类的基本概念

C# 图解教程 第5版 —— 第5章 类的基本概念

文章目录 5.1 类的概述5.2 程序和类&#xff1a;一个简单的示例&#xff08;*&#xff09;5.3 声明类&#xff08;*&#xff09;5.4 类成员&#xff08;*&#xff09;5.4.1 字段&#xff08;*&#xff09;5.4.2 方法 5.5 创建变量和类的实例&#xff08;*&#xff09;5.6 为数据…
阅读更多...
进程的虚拟地址空间

进程的虚拟地址空间

一、 对于C/C程序员&#xff0c;我们看到的程序中的地址&#xff0c;都不是物理地址&#xff0c;而是操作系统映射的虚拟地址/线性地址&#xff0c;每一个进程都映射了同样结构的虚拟地址空间&#xff0c;让进程以为自己在独享内存资源&#xff0c;下图是以Linux下32位操作系统…
阅读更多...
SpringMVC源码分析（三）HandlerExceptionResolver启动和异常处理源码分析

SpringMVC源码分析（三）HandlerExceptionResolver启动和异常处理源码分析

问题&#xff1a;异常处理器在SpringMVC中是如何进行初始化以及使用的&#xff1f; Spring MVC提供处理异常的方式主要分为两种&#xff1a; 1、实现HandlerExceptionResolver方式&#xff08;HandlerExceptionResolver是一个接口&#xff0c;在SpringMVC有一些默认的实现也可以…
阅读更多...
STM32Cube高效开发教程＜基础篇＞(六)----FSMC连接TFT-LCD屏

STM32Cube高效开发教程＜基础篇＞(六)----FSMC连接TFT-LCD屏

声明：本人水平有限，博客可能存在部分错误的地方，请广大读者谅解并向本人反馈错误。    本专栏博客参考《STM32Cube高效开发教程(基础篇)》，有意向的读者可以购买正版书籍辅助学习，本书籍由王维波老师、鄢志丹老师、王钊老师倾力打造，书籍内容干货满满。 一、 FSMC连接…
阅读更多...
“第四十二天”

“第四十二天”

这个&#xff0c;之前用的b去存储a的总和和排名&#xff0c;后来在比较的过程中&#xff0c;只改变的b的值&#xff0c;却没有改变a的值&#xff0c;但在比较语文成绩的时候用的还是a&#xff0c;这个时候a和b同样是第i个对应的可能不是同一个对象了 &#xff0c;因为上面b的值…
阅读更多...
rabbitMq (2)

rabbitMq (2)

RabbitMQ 消息应答与发布 文章目录 1. 消息应答1.2 自动应答1.2 手动应答1.3 代码案例 2. RabbitMQ 持久化2.1 队列持久化2.2 消息持久化 3. 不公平分发4. 预取值分发5. 发布确认5.1 发布确认逻辑5.2 开启发布确认的方法5.3 单个确认发布5.4 批量确认发布5.5 异步确认5.5.1 处理…
阅读更多...
《动手学深度学习 Pytorch版》 8.7 通过时间反向传播

《动手学深度学习 Pytorch版》 8.7 通过时间反向传播

8.7.1 循环神经网络的梯度分析 本节主要探讨梯度相关问题&#xff0c;因此对模型及其表达式进行了简化&#xff0c;进行如下表示&#xff1a; h t f ( x t , h t − 1 , w h ) o t g ( h t , w o ) \begin{align} h_t&f(x_t,h_{t-1},w_h)\\ o_t&g(h_t,w_o) \end{ali…
阅读更多...
在 VSCode 中使用 PlantUML

在 VSCode 中使用 PlantUML

最近&#xff0c;因为工作需要绘制一些逻辑图&#xff0c;我自己现在使用的是 PlantUML 或者 mermaid&#xff0c;相比之下前者更加强大。不过它的环境也麻烦一些&#xff0c;mermaid 在一些软件上已经内置了。但是 PlantUML 一般需要自己本地安装或者使用远程服务器&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023