【算法】排序详解（快速排序，堆排序，归并排序，插入排序，希尔排序，选择排序，冒泡排序）

目录

排序的概念：

排序算法的实现：

插入排序：

希尔排序：

选择排序：

堆排序：

冒泡排序：

快速排序：

快速排序的基本框架：

1.Hoare法

2. 挖坑法

3.前后指针法

 快排的优化：

1. 三数取中法选key

2. 小区间使用插入排序

优化代码：

常见问题：

归并排序：

总结：

结语：

排序的概念：

排序：

所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

稳定性：

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

内部排序：

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

外部排序：

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

常见的排序算法：

直接插入排序，希尔排序，选择排序，堆排序，冒泡排序，快速排序，归并排序。

排序算法的实现：

说明：由于swap函数经常出现，为了使文章更加整洁，这里给出源码，下文直接调用不在说明。

 private static void swap(int[] array,int i,int j){int tmp = array[i];array[i] = array[j];array[j] = tmp;}

插入排序：

思路：在待排序的元素中，假设前n-1个元素已有序，现将第n个元素插入到前面已经排好的序列中，使得前n个元素有序。按照此法对所有元素进行插入，直到整个序列有序。

动图演示如下：

代码实现如下：

 public static void insertSort(int[] array){for(int i = 1;i < array.length; i++){int j = i-1;int tmp = array[i];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. 稳定性：稳定

希尔排序：

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

动图演示：

代码实现如下：

在shellSort里面确定组的大小，在shell里面进行排序，通过计算确定gap的关系，间隔运行，一次通过。

 public static void shellSort(int[] array){int gap = array.length;while(gap > 1){gap /= 2;shell(array,gap);}}public static void shell(int[] array,int gap){for(int i = gap; i < array.length; i++){int j = 0;j = i-gap;int tmp = array[i];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. 稳定性：不稳定

选择排序：

思路：

（1）在元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素。

（2）若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换。

（3）在剩余的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-1; i++){int minIndex = i;for(int j = i+1;j < array.length; j++){if(array[j] < array[minIndex]){minIndex = j;}}swap(array,i,minIndex);}}private 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. 稳定性：不稳定

堆排序：

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

动图演示：

代码实现如下：

从小到大用大根堆

从大到小用小根堆

下面代码为大根堆

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

 结果演示：

堆排序的特性总结：

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

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

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

4. 稳定性：不稳定 

冒泡排序：

简单就不给思路了

动图演示：

 代码实现如下：

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 == false){return;}}}

 结果演示：

冒泡排序的特性总结：

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

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

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

4. 稳定性：稳定 

快速排序：

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

快速排序的基本框架：

 //快排的框架public static void quickSort(int[] array,int left,int right){if(right <= left){return;}int div = partition(array,left,right);quickSort(array,left,div-1);quickSort(array,div+1,right);}

这是还没优化的。

partition可以得到left和right相遇的下标。

关于partition有三种求法分别是Hoare版，挖坑法，前后指针。

其中最常用的是挖坑法。

1.Hoare法

动图如下：

代码实现： 

 //Hoareprivate static int partition(int[] array,int left,int right){int i = left;int j = right;int pivot = array[left];while(j > i){while(j > i && array[j] >= pivot){j--;}while(j > i && array[i] <= pivot){i++;}swap(array,i,j);}swap(array,i,left);return i;}

2. 挖坑法

动图如下：

 代码实现： 

//挖坑法private static int partition(int[] array,int left,int right){int i = left;int j = right;int pivot = array[left];while(j > i){while(j > i && array[j] >= pivot){j--;}array[i] = array[j];while(j > i && array[i] <= pivot){i++;}array[j] = array[i];}array[i] = pivot;return i;}

3.前后指针法

代码如下：

 //前后指针法private static int partition(int[] array,int left,int right){int prev = left;int cur = left+1;while(cur <= right){if(array[cur] < array[left] && array[++prev] != array[cur]){swap(array,cur,prev);}cur++;}swap(array,prev,left);return prev;}

 快排的优化：

1. 三数取中法选key

使用该优化方法可以有效减少当数组有序时变成单叉树的时间复杂度。

基本思路：选取数组中第一个数，中间数和最后一个数比较大小，将其中中间值和最左边交换，这样可以使mid左后两边数组个数尽可能相等。

代码如下：

private static int middleNum(int[] array,int left,int right){int mid = left + ((right - left) >> 1);if(array[left] < array[right]){if(array[mid] < array[left]){return left;}else if(array[mid] < array[right]){return mid;}else{return right;}}else{if(array[mid] < array[right]){return right;}else if(array[mid] < array[left]){return mid;}else{return left;}}}
2. 小区间使用插入排序

思路：我们直到插入排序在数组接近有序时是非常快的，而快排最后在堆上调用的空间是非常大的，故在小区间上使用插入排序可以达到优化的效果。

代码如下：

//优化1if(right - left +1 <= 15){insertSort2(array,left,right);return;}private static void insertSort2(int[] array,int left,int right){if(left >= right){return;}for(int i = 1 + left;i <= right;i++){int tmp = array[i];//都定义可读性好int j = i-1;for(;j >= left;j--){if(array[j] > tmp){array[j+1] = array[j];}else{break;}}array[j+1] = tmp;}}
优化代码：

为节省文章长度，下面个代码在上面给出，下面我就不给总代码了（抱歉）。

public static void quickSort(int[] array,int left,int right){if(right <= left){return;}//优化1if(right - left +1 <= 15){insertSort2(array,left,right);return;}//优化2int index = middleNum(array,left,right);swap(array,index,left);int div = partition(array,left,right);quickSort(array,left,div-1);quickSort(array,div+1,right);}

快速排序的特性总结：

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

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

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

4. 稳定性：不稳定

常见问题：

1.在partition 方法中array[j] >= pivot 和 array[i] <= pivot中的等号能否去掉？

答：不能，因为当left和right下标的值等于pivot时会陷入死循环。

2.在partition 方法中能不能先从left开始遍历？

答：不能，因为这样最后和第一个数交换时会把比pivot大的数给到第一个（假设取得pivot取的都是第一个数）

归并排序：

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

图片如下：

 代码实现：

先拆分后合并用递归实现拆分，merge实现合并。

//归并排序public static void mergeSort(int[] array,int left,int right){if(left >= right){return;}int mid = left + ((right - left) >> 1);mergeSort(array,left,mid);mergeSort(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 s2 = mid + 1;int e1 = mid;int e2 = right;int k = 0;int[] tmpArr = new int[right - left + 1];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 < k;i++){array[i + left] = tmpArr[i];//特别注意要加left}}

归并排序总结：

1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

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

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

4. 稳定性：稳定

总结：

重点掌握：快排，堆排，归并，插入。

计数，基数，桶，这三个排序了解即可（代码不会写都没事不考的）

 

结语：

其实写博客不仅仅是为了教大家，同时这也有利于我巩固自己的知识点，和一个学习的总结，由于作者水平有限，对文章有任何问题的还请指出，接受大家的批评，让我改进，如果大家有所收获的话还请不要吝啬你们的点赞收藏和关注，这可以激励我写出更加优秀的文章。

 

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

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

相关文章

假期day7

假期day7

设计qq界面 代码 ui->lab1->setPixmap(QPixmap(":/pictrue/denglu.webp"));ui->lab1->setScaledContents(true);ui->lab2->setPixmap(QPixmap(":/pictrue/passwd.jpg"));ui->lab2->setScaledContents(true);ui->lab3->setP…
阅读更多...
Docker容器输入汉字触发自动补全

Docker容器输入汉字触发自动补全

一、描述 输入汉字自动触发补全&#xff1a; Display all 952 possibilities? (y or n)是因为容器中没有中文字符集和中文字体导致的&#xff0c;安装中文字体&#xff0c;并设置字符集即可。 二、解决 1、安装字符集 &#xff08;1&#xff09;查看系统支持的字符集 lo…
阅读更多...
Ubuntu下anaconda的常用操作

Ubuntu下anaconda的常用操作

Ubuntu下anaconda的安装及常用操作 安装Anaconda 下载Anaconda&#xff1a;在Anaconda官网下载适合你系统的Anaconda安装包&#xff08;通常是64位的Linux版本&#xff09;。 安装Anaconda 在终端中导航到你下载Anaconda安装包的目录&#xff0c;然后运行以下命令安装Anacon…
阅读更多...
蓝桥云课-2024-第5场入门赛

蓝桥云课-2024-第5场入门赛

参赛地址&#xff1a; 第 5 场 小白入门赛 - 蓝桥云课 (lanqiao.cn) 题目列表&#xff1a; 第一题&#xff1a;是签到题&#xff0c;就不需要解释了 第二题&#xff1a;欢迎参加福建省大学生程序设计竞赛&#xff08;题目&#xff09; 主要思路&#xff1a; 就是分类&#…
阅读更多...
Leecode之反转链表

Leecode之反转链表

一.题目及剖析 https://leetcode.cn/problems/reverse-linked-list/description/ 二.思路引入 设定三个指针,n1指向空, n2指向head,n3指向下一个元素,将n2->next指向n1,然后三个指针向后遍历重复即可 三.代码引入 /*** Definition for singly-linked list.* struct List…
阅读更多...
KMP算法|next指针|详细讲解学习

KMP算法|next指针|详细讲解学习

KMP 算法介绍 KMP 算法是基于串的朴素模式匹配算法优化的。 串的朴素模式匹配算法是将主串中所有的与模式串长度相等的子串与模式串进行比较&#xff0c;如果模式串与进行比较的的子串相等&#xff0c;就匹配成功&#xff0c;否则匹配失败。 在 KMP 算法的理解的基础上&#x…
阅读更多...
【Rust】——猜数游戏

【Rust】——猜数游戏

&#x1f383;个人专栏&#xff1a; &#x1f42c; 算法设计与分析&#xff1a;算法设计与分析_IT闫的博客-CSDN博客 &#x1f433;Java基础&#xff1a;Java基础_IT闫的博客-CSDN博客 &#x1f40b;c语言&#xff1a;c语言_IT闫的博客-CSDN博客 &#x1f41f;MySQL&#xff1a…
阅读更多...
vtk三维场景基本要素 灯光、相机、颜色、纹理映射 简介

vtk三维场景基本要素 灯光、相机、颜色、纹理映射 简介

整理一下VTK 三维场景基本要素&#xff0c;后面会一一进行整理&#xff1b; 1. 灯光 vtkLight 剧场里有各式各样的灯光&#xff0c;三维渲染场景中也一样&#xff0c;可以有多个灯光存在。灯光和相机 是三维渲染场景必备的要素&#xff0c;vtkRenderer会自动创建默认的灯光和…
阅读更多...
小游戏和GUI编程(5) | SVG图像格式简介

小游戏和GUI编程(5) | SVG图像格式简介

小游戏和GUI编程(5) | SVG图像格式简介 0. 问题 Q1: SVG 是什么的缩写&#xff1f;Q2: SVG 是一种图像格式吗&#xff1f;Q3: SVG 相对于其他图像格式的优点和缺点是什么&#xff1f;Q4: 哪些工具可以查看 SVG 图像&#xff1f;Q5: SVG 图像格式的规范是怎样的&#xff1f;Q6…
阅读更多...
自动化AD域枚举和漏洞检测脚本

自动化AD域枚举和漏洞检测脚本

linWinPwn 是一个 bash 脚本&#xff0c;可自动执行许多 Active Directory 枚举和漏洞检查。该脚本基于很多现有工具实现其功能&#xff0c;其中包括&#xff1a;impacket、bloodhound、netexec、enum4linux-ng、ldapdomaindump、lsassy、smbmap、kerbrute、adidnsdump、certip…
阅读更多...
板块一 Servlet编程：第一节 Servlet的实现与生命周期 来自【汤米尼克的JAVAEE全套教程专栏】

板块一 Servlet编程：第一节 Servlet的实现与生命周期 来自【汤米尼克的JAVAEE全套教程专栏】

板块一 Servlet编程&#xff1a;第一节 Servlet的实现与生命周期 一、Servlet相关概念Serlvet的本质 二、中Web项目中实现Servlet规范&#xff08;1&#xff09;在普通的Java类中继承HttpServlet类&#xff08;2&#xff09;重写service方法编辑项目对外访问路径 二、Servlet工…
阅读更多...
《乱弹篇（十三）明朝事儿》

《乱弹篇（十三）明朝事儿》

2024年农历除夕夜&#xff0c;因追剧收看电视连续剧《后宫》而放弃了收看一年一度的《春晚》&#xff0c;至到春节&#xff08;农历正月初一&#xff09;晚才看完了《后宫》。 社交网站“必应”图片《后宫》 电视连续剧《后宫》&#xff0c; 讲的是明朝英宗末年的历史故事&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023