【算法】常见排序算法总结

堆排序

================================================================

原理

---

1. 堆排序是利用堆这种数据结构设计出的一种排序算法，其是选择排序的一种，它利用大顶堆(小顶堆)堆顶元素是最大值(最小值)这一特性，使得每次从无序中选择最大值(最小值)变得简单。

2. 排升序要建大堆；排降序要建小堆。

具体步骤如下

step1：先将带排序的数组构造成一个大根堆，假设有如下数组：int[] array2={2,3,4,1,6,5};

构造成大根堆如下：

step2：将堆顶元素与堆尾元素交换：

step3：将除6以外其他的所有元素继续构造大根堆：

以此类推，然后再将堆顶元素与堆中倒数第二个元素交换，换完之后除了倒数第一个和倒数第二个元素以外，其他元素继续构造成大堆，最终会得到有序的数组

同理，如果要从大到小排，则构建小堆即可！

实现

---

public static void siftDown(int[] array,int root,int len) {

int parent = root;

int child = 2*parent+1;

while (child < len) {

//找到左右孩子的最大值

//1、前提是你得有右孩子

if(child+1 < len && array[child] < array[child+1]) {

child++;

}

//child的下标就是左右孩子的最大值下标

if(array[child] > array[parent]) {

int tmp = array[child];

array[child] = array[parent];

array[parent] = tmp;

parent = child;

child = 2*parent+1;

}else {

break;

}

}

}

public static void createHeap(int[] array) {

//从小到大排序 -》 大根堆

for (int i = (array.length-1 - 1) / 2; i >= 0 ; i–) {

siftDown(array,i,array.length);

}

}

public static void heapSort(int[] array) {

createHeap(array);//O(n)

int end = array.length-1;

while (end > 0) {//O(N*logN)

int tmp = array[end];

array[end] = array[0];

array[0] = tmp;

siftDown(array,0,end);

end–;

}

}

排序性能分析

---

1. 时间复杂度：O(N* log(N))（最好和最坏的都是这个）

2. 空间复杂度：O（1）（在整个调整的过程中并没有重新定义数组）

3. 稳定性：不稳定

这个堆排序我上一篇博客中有详细地讲过哦，相信大家看完后一定会有收获的有关堆的相关知识点

冒泡排序

=================================================================

原理

---

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。一直重复进行上述步骤，直到没有元素再需要交换，也就是说该数列已经排序完成。

实现

---

public static void bubbleSort(int[] array) {

for (int i = 0; i < array.length-1; i++) {

for (int j = 0; j < array.length-1-i; j++) {

if(array[j] > array[j+1]) {

int tmp = array[j];

array[j] = array[j+1];

array[j+1] = tmp;

flg = true;

}

}

}

}

排序性能分析

---

1. 时间复杂度：最好/最坏：O（N2 ），若优化，则最好的情况下时间复杂度为O（n）

2. 空间复杂度：O（1）

3. 稳定性：稳定

优化方法

public static void bubbleSort(int[] array) {

// boolean flg = false;

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]) {

int tmp = array[j];

array[j] = array[j+1];

array[j+1] = tmp;

flg = true;

}

}

if(flg == false) {

break;

}

}

}

设置一个flg，若当前排序时已经有序，可以提前结束本次循环

快速排序

=================================================================

原理

---

1. 快速排序是对冒泡排序的一种改进。

2. 排序前首先选择一个基准值（pivot）将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再对左右两个区间选取基准值，重复此步骤，采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度为1，代表已经有序，或者小区间的长度为0，代表没有数据，排序完成！整个排序过程可以递归进行，也可以非递归进行（如使用栈）

基准的选取（递归实现快速排序）

---

挖坑法

定义两个变量，假如数组的首元素位置下标是low，数组的尾元素位置下标是high，挖坑法为固定位置选取基准法，比如让low下标的元素作为基准，让其存到临时变量tmp当中，然后将high从后往前遍历，找比tmp的值小的数字，若找到，则将这个值存到low下标对应的位置中。接着让low从左到右遍历去找比tmp的值大的元素，若找到，则将其值存到high下标对应的位置中，以此循环。直到low和high相遇，那么就把tmp的值放到相遇位置作为基准即可。这样即可实现把要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小了

实现代码：

public static int partition(int[] array,int low,int high) {

int tmp = array[low];

while (low < high) {

while (low < high && array[high] >= tmp) {

high–;

}

array[low] = array[high];

while (low < high && array[low] <= tmp) {

low++;

}

array[high] = array[low];

}

array[low] = tmp;

return low;

}

有了基准后，就可以进行快速排序的下一步了，然后再对左右两个小区间选取基准值进行排序，下面我们将使用递归的方法：

import java.util.Arrays;

public class TestDemo {

public static int partition(int[] array,int low,int high) {

int tmp = array[low];

while (low < high) {

while (low < high && array[high] >= tmp) {

high–;

}

array[low] = array[high];

while (low < high && array[low] <= tmp) {

low++;

}

array[high] = array[low];

}

array[low] = tmp;

return low;

}

public static void quick(int[] array,int start,int end) {

if(start >= end) {

return;

}

int pivot = partition(array,start,end);

quick(array,start,pivot-1);

quick(array,pivot+1,end);

}

public static void quickSort1(int[] array) {

quick(array,0,array.length-1);

}

public static void main(String[] args) {

int[] array={12,5,37,41,55,28,6,1,69,17};

quickSort1(array);

System.out.println(Arrays.toString(array));

}

}

打印的结果为：

排序完成！

性能分析

1. 时间复杂度：

最好情况：O（N\*logN）（每一次排序时分割区间都是均匀的）  

最坏情况：O（N2）（对已经有序的一对数据排序）

2. 空间复杂度：

最好：O（logN）  

最坏：O（N）

3. 稳定性：不稳定

三数取中

对于上述用挖坑法递归进行快速排序时，因为空间复杂度为O（n），那么当数据足够多时且越趋于有序而导致排序分割的区间不均匀时，那可能会栈溢出（因为递归是在栈上开辟内存的），因此，我们可以用三数取中来实现让排序的区间更趋于均匀，从而提升算法的效率。

具体思路：

让low下标等于数组首元素位置，让high等于数组最后一个元素的位置，定义一个mid使其等于数组的中间位置，然后让low下标的值等于这三个下标对应的值第二大的，即中间大小的值

实现代码：

mport java.util.Arrays;

public class TestDemo {

public static int partition(int[] array,int low,int high) {

int tmp = array[low];

while (low < high) {

while (low < high && array[high] >= tmp) {

high–;

}

array[low] = array[high];

while (low < high && array[low] <= tmp) {

low++;

}

array[high] = array[low];

}

array[low] = tmp;

return low;

}

public static void swap(int[] array,int i,int j) {

int tmp = array[i];

array[i] = array[j];

array[j] = tmp;

}

public static void selectPivotMedianOfThree(int[] array,int start,int end,int mid) {

//array[mid] <= array[start] <= array[end]

if(array[mid] > array[start]) {

swap(array,start,mid);

}// array[mid] <= array[start]

if(array[start] > array[end]) {

swap(array,start,end);

}// array[start] <= array[end]

if(array[mid] > array[end]) {

swap(array,start,end);

}// array[mid] <= array[end]

}

public static void quick(int[] array,int start,int end) {

if(start >= end) {

return;

}

int mid = (start+end)/2;

selectPivotMedianOfThree(array,start,end,mid);

int pivot = partition(array,start,end);

quick(array,start,pivot-1);

quick(array,pivot+1,end);

}

public static void quickSort1(int[] array) {

quick(array,0,array.length-1);

}

public static void main(String[] args) {

int[] array={12,5,37,41,55,28,6,1,69,17};

quickSort1(array);

System.out.println(Arrays.toString(array));

}

}

优化

利用递归法求基准进行快速排序时，当分割的区间越来越小时，其区间内的数据越趋于有序，因此我们可以设定一个区间范围，然后在这个区间范围进行直接插入排序，排好序之后就不再递归了，这样可以大大提高算法的效率

直接插入排序部分代码：

//判断两个下标之间的数据个数

if(end-start+1 <= 100) {

insertSort2(array,start,end);//这里要调用之前写好的直接插入排序的代码

return;//这里一定要return

利用栈（非递归实现快速排序）

除了上面我们可以利用递归实现快速排序，我们也可以利用非递归实现快速排序，其步骤如下：

1. 先选取基准（pivot），以挖坑法为例。

2. 找到基准后，把基准左区间两端的下标和右区间两端的下标放入栈里

3. 判断栈是否为空，若不为空，则弹出栈顶两个元素。

4. 继续进行步骤一

注意：当一个区间至少有两个元素的时候才可以入栈。

实现动图（以找到基准为例）

实现代码：

public static void quickSort(int[] array) {

Stack stack = new Stack<>();

int start = 0;

int end = array.length-1;

int pivot = partition(array,start,end);

//左边有2个元素及以上

if(pivot > start+1) {

stack.push(0);

stack.push(pivot-1);

}

if(pivot < end-1) {

stack.push(pivot+1);

stack.push(end);

}

while (!stack.empty()) {

end = stack.pop();

start = stack.pop();

pivot = partition(array,start,end);

//左边有2个元素及以上

if(pivot > start+1) {

stack.push(0);

stack.push(pivot-1);

}

if(pivot < end-1) {

stack.push(pivot+1);

stack.push(end);

}

}

}

归并排序

=================================================================

原理

---

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

递归实现

---

实现代码

import java.util.Arrays;

public class Test {

public static void merge(int[] array,int low,int mid,int high) {

int s1 = low;

int e1 = mid;

int s2 = mid+1;

int e2 = high;

int[] tmp = new int[high-low+1];

int k = 0;//代表tmp数组的下标:

while (s1 <= e1 && s2 <= e2) {

if(array[s1] <= array[s2]) {

tmp[k++] = array[s1++];

}else {

tmp[k++] = array[s2++];

}

}

while (s1 <= e1){

//情况1：说明第2个归并段没有了数据 把第1个归并段剩下的数据 全部拷贝过来

tmp[k++] = array[s1++];

}

while (s2 <= e2) {

//情况2：说明第1个归并段没有了数据 把第2个归并段剩下的数据 全部拷贝过来

tmp[k++] = array[s2++];

}

//tmp数组当中 存储的就是当前归并好的数据

for (int i = 0; i < tmp.length; i++) {

array[i+low] = tmp[i];

}

}

public static void mergeSortInternal(int[] array,int low,int high) {

if(low >= high) {

return;

}

int mid = (low+high) / 2;

mergeSortInternal(array,low,mid);

mergeSortInternal(array,mid+1,high);

//合并的过程

merge(array,low,mid,high);

}

public static void mergeSort1(int[] array) {

mergeSortInternal(array, 0,array.length-1);

}

测试

排序性能分析

1. 时间复杂度：O（N*logN）（N代表数组元素的个数，logN代表了二叉树的高度）

2. 空间复杂度：O（N）（开辟了长度为N的临时数组）

3. 稳定性：稳定

非递归实现

---

public static void merge(int[] array,int gap) {

int[] tmp = new int[array.length];

int k = 0;

int s1 = 0;

int e1 = s1+gap-1;

int s2 = e1+1;

int e2 = s2+gap-1 < array.length ? s2+gap-1 : array.length-1;

//保证有两个归并段

while (s2 < array.length) {

while (s1 <= e1 && s2 <= e2) {

if(array[s1] <= array[s2]) {

tmp[k++] = array[s1++];

}else {

tmp[k++] = array[s2++];

}

}

while (s1 <= e1) {

tmp[k++] = array[s1++];

}

while (s2 <= e2) {

tmp[k++] = array[s2++];

}

//一组完了 确定新的区间的开始和结束

s1 = e2+1;

e1 = s1+gap-1;

s2 = e1+1;

e2 = s2+gap-1 < array.length ? s2+gap-1 : array.length-1;

}

//e2 > array.length

while (s1 <= array.length-1) {

tmp[k++] = array[s1++];

}

for (int i = 0; i < tmp.length; i++) {

array[i] = tmp[i];

}

}

public static void mergeSort(int[] array) {

for (int i = 1; i < array.length; i*=2) {

merge(array,i);

}

}

归并排序速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列

利用归并实现外部排序

---

外部排序基本概念

本篇本章前段我们讨论了的排序方式都属于基于比较类的排序，也是计算机的内部排序：

内部排序指的是待排序记录存放在计算机随机存储器中进行排序的过程

而计算机中还有一种排序，就是外部排序：

外部排序值的是排序记录的数量很大，以致内存一次不能容纳全部记录，在排序过程中尚需堆外村进行访问的排序过程

利用归并思想实现

外部排序基本上由两个相对独立的阶段组成。首先，按可用内存大小，将外存上含n个记录的文件分成若干长度为l的子文件或段(segment)，依次读入内存并利用有效的内部排序方法对它们进行排序，并将排序后得到的有序子文件重新写入外存，通常称这些有序子文件为归并段或顺串(run)；然后，对这些归并段进行逐趟归并，使归并段(有序的子文件)逐渐由小至大，直至得到整个有序文件为止。显然，第一阶段的工作是前面排序部分已经讨论过的内容。现在主要讨论第二阶段即归并的过程。先从一个具体例子来看外排中的归并是如何进行的？

假设有一个含10000个记录的文件，首先通过10次内部排序得到10个初始归并段R1～R10，其中每一段都含1000个记录。然后对它们作如下图所示的两两归并，直至得到一个有序的文件为止。

从上图可见，由10个初始归并段到一个有序文件，共进行了4趟归并，每一趟从m个归并段得到【m/2】个归并段。这种归并方法称为2-路平衡归并。

将两个有序段归并成一个有序段的过程，若在内存进行，则很简单，merge过程便可实现此归并。但是，在外部排序中实现两两归并时，不仅要调用merge过程，而且要进行外存的读/写，这是由于我们不可能将两个有序段及归并结果段同时存放在内存中的缘故。因为对外存上信息的读/写是以“物理块”为单位的，假设在上例中每个物理块可以容纳200个记录，则每一趟归并需进行50次“读”和50次“写”，4趟归并加上内部排序时所需进行的读/写使得在外排中总共需进行500次的读/写。

算法效率分析

一般情况下，外部排序所需总的时间=内部排序（产生初识归并段）所需总的时间（m_t[IS]）+外部信息读写的时间（d_t[IO]）+内部归并所需得时间（s*ut[mg]）

其中：t[IS]是为得到一个初始归并段进行内部排序所需时间的均值；t[IO]是进行一次外存读/写时间的均值；ut[mg]是对u个记录进行内部归并所需时间；m为经过内部排序之后得到的初始归并段的个数；s为归并的趟数；d为总的读/写次数。由此，上例10000个记录利用2-路归并进行外排所需总的时间为：

10×t[IS]+500×t[IO]+4×10 000t[mg]

其中t[IO]取决于所用的外存设备，显然，t[IO]较t[mg]要大得多。因此，提高外排的效率应主要着眼于减少外存信息读写的次数d。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。

下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）

最新整理电子书

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
较t[mg]要大得多。因此，提高外排的效率应主要着眼于减少外存信息读写的次数d。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。[外链图片转存中…(img-4ZRmmK4K-1713552730907)]

[外链图片转存中…(img-iuWMYhG8-1713552730908)]

[外链图片转存中…(img-TAPBAoe8-1713552730909)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

最后

针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。

下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）

[外链图片转存中…(img-o18ZcTMJ-1713552730911)]

最新整理电子书

[外链图片转存中…(img-kQIkSS3j-1713552730911)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！