1 概念

1.1 排序

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
平时的上下文中，如果提到排序，通常指的是排升序（非降序）。
通常意义上的排序，都是指的原地排序(in place sort)。

1.2 稳定性

两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。
如果当前这个排序，在排序过程中没有发生跳跃式的交换，那么我们认为这个排序是稳定的排序。所以堆排序不是一个稳定的排序。

1. 一个排序如果是稳定的排序，那么它也可以被实现为一个不稳定的排序；
2. 但是如果一个排序本身就是不稳定的排序，那么就不可能实现为一个稳定的排序。

如下图所示就是一个稳定的排序：

2 常见基于比较排序算法总览

内部排序： 所有的数据都是在内存上的（程序的内存），也就是说这些所要排序的数据要在内存上可以存储。
外部排序： 数据都在磁盘上E F D等。
如下图所示就是常见的排序算法：

3 插入排序

3.1 直接插入排序

3.1.1 思想

直接插入排序是一种最简单的排序方法，它的基本思想就是：把一个数据插入到一个有序的序列中去，从而得到一个新的有序序列。
其基本步骤可以概括为两步：

1. 取出一个元素，留出空位；
2. 符合条件的元素右移，把取出的元素插入。

那么这样的话，我们就需要一个辅助的变量来临时缓存这个被取出的变量，一般我们把这个辅助变量称之为“哨兵”。

那么给定一组无序的数据, 实现直接插入排序的具体过程是什么样的呢?是否是一个稳定的排序呢？下面我们给定一组数据为{22， 11， 33， 10， 22}，对其进行直接插入排序具体过程如下所示：

1. 第一趟插入排序：
   因为是取出一个元素和前一个元素对比，根据大小关系决定插入到第一个元素的左边或者右边，所以第一趟排序应该从取出第二个元素开始，即i初始值为2。
   假设给定一个序列{22， 11， 33， 10， 22}，首先取出第二个元素11，用11和22比较，22大于11则22右移一位，然后把11插入到22的位置，即0号下标处。在第一趟排序中，进行了一次比较，一次元素移动。通过第一趟排序形成了一个包含两元素的有序子序列。
2. 第二趟插入排序：
   取出第三个元素，第三个元素array[2]与第二个元素array[1]对比，若：
   （1）array[2]>array[1]，那么就把array[2]插入到原处，即不进行任何操作，结束本趟插入排序；
   （2）如果array[2]<array[1]，那么array[1]右移一位，array[2]继续和array[0]比较；如果array[2]>array[0]，那么array[2]插入到1号位置，结束本趟插入排序；
   （3）如果array[2]<array[0]，那么array[0]右移一位，array[2]插入到0号位置。
   
   第二趟排序进行了一次比较，0次元素移动（这是最好的情况，即本来子序列就已经从小到大了）。经过第二趟排序，有序子序列加一，这也是插入法之所以称为插入的原因：把一个记录插入到一个有序的序列中。
3. 第三趟插入排序：
   取出第四个元素，执行比较-移动-插入三部曲操作。
   
   第三趟排序，进行了三次比较，三次移动，这是最坏的情况，即每次比较都要移动。经过第三趟排序，有序序列再次加1，无序序列减一。
4. 第n-1趟插入排序：
   第n-1趟插入排序，将进行最少1次比较，0次移动；最多n-1次比较，n-1次移动。
   
   且通过示意图可以看到，红色22本来就在黑色22前面，经过插入排序后，红色22依然在黑色22前面，所以插入排序是稳定排序。

注： 此小节内容摘自博客https://blog.csdn.net/qq_43471489/article/details/125583368，具体可点击链接进入该博客学习。

3.1.2 实现

直接插入排序实现代码如下所示：

import java.util.Arrays;
public class TestSort {/** 时间复杂度:*     最坏情况下：当数据是无序的情况下是 O(n^2)*     最好情况下：当数据有序的时候可以达到 O(n)*     所以：结论：越有序越快。* *     题目：*       1.当前有一组待排序序列，但是这组待排序序列大部分是有序的，请问下面哪个排序更适合？*         答案：直接插入排序。*       2. 另外：直接插入排序一般也会用在一些排序的优化上。*         答案：快速排序* * 空间复杂度：* 稳定性：稳定的排序* */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;}}public static void main(String[] args) {int[] array = {10,3,2,7,19,78,65,127};System.out.println(Arrays.toString(array));insertSort(array);System.out.println(Arrays.toString(array));}
}

3.1.3 性能分析

时间复杂度			空间复杂度
最好	平均	最坏
O(n)	O(n^2)	O(n^2)	O(1)
数据有序		数据逆序

稳定性： 稳定。
特点： 插入排序，初始数据越接近有序，时间效率越高。

3.2 折半插入排序

3.2.1 思想

折半插入排序是将折半查找方法与直接插入排序方法相结合，借助二分查找的思想，先查找插入位置，再移动数据，最后插入到正确的位置。
那么给定一组无序的数据, 实现折半插入排序的具体过程是什么样的呢?下面我们给定一组数据为{6， 1， 3， 5， 4，2}，对其进行折半插入排序具体过程如下所示：

1. 第一趟排序：
   折半插入排序首先把第一个元素直接放到排好序的数组中，第二个元素可以使用直接插入排序法进行排序，从第三个元素开始进行插入排序。
   
2. 第二趟排序：
   l =0表示左，h=1表示右，m=(l+h)/2=1表示中间，其位置如下表所示，元素arr[2]=3是待插入元素，首先将其缓存到t。
   
   此时arr[m] < t，因此修改l为m+1=1，之后重新计算m=(l+h)/2=1。
   
   再次比较出现arr[m] > t，因此修改h为m-1=0,出现了h<l的情形，因此结束本趟的排序，记录h的位置（h=0），然后把h+1位置的元素向后移动一位，将t的值插入到arr[h+1]。
   
3. 第三趟排序：
   将元素arr[3]缓存给t，然后重复第二趟排序的方法即可。
   
4. 第四趟排序和第五趟排序，同上述方法一样，经过五趟排序之后，就完成了对该数组的折半插入排序。

我们都知道直接插入排序是一个边比较边移动的过程，而折半插入排序是先确定插入的位置，再来进行移动。插入排序的效率是由比较的次数和移动的次数共同决定的，而折半插入排序就是通过降低比较的次数来提高排序的效率。
在有序区间选择数据应该插入的位置时，因为区间的有序性，可以利用折半查找的思想。
注： 此小节内容摘自博客https://blog.csdn.net/sunnyoldman001/article/details/127032485，具体可点击链接进入该博客学习。

3.2.2 实现

折半插入排序实现代码如下所示：

public static void bsInsertSort(int[] array) {for (int i = 1; i < array.length; i++) {int v = array[i];int left = 0;int right = i;// [left, right)// 需要考虑稳定性while (left < right) {int m = (left + right) / 2;if (v >= array[m]) {left = m + 1;} else {right = m;}}// 搬移for (int j = i; j > left; j--) {array[j] = array[j - 1];}array[left] = v;}
}

3.2.3 性能分析

时间复杂度			空间复杂度
最好	平均	最坏
O(n)	O(n^2)	O(n^2)	O(1)
数据有序		数据逆序

稳定性： 稳定。
特点： 通过减少元素比较次数使得排序效率得到提高。

3.3 希尔排序

3.3.1 思想

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

希尔排序法的基本思想是：先选定一个整数gap，把待排序序列中所有数据分成gap个组，所有距离为(数据总数/gap)的数据分在同一组内，并对每一组内的数据分别进行直接插入排序。然后，取、重复上述分组和排序的工作。当到达gap=1时，所有记录在统一组内排好序。

那么给定一组无序的数据, 实现希尔排序的具体过程是什么样的呢?如下图所示给定了15个数据，进行希尔排序的具体过程为：

1. 我们先选定一个整数gap=5，也就是将这组数据分成了5组；
2. 所有距离为15/5 = 3的数据分在同一组内（也就是同种颜色线条所指的三个数字为一组，即12，8，7就是第一组；5，27，4为第二组等）。
3. 对每一组内的数据分别进行直接插入排序得到一个结果。
4. 对于这个结果我们再选定一个整数gap=3，也就是将这组数据分成了3组，所有距离为5的数据分在同一组内，对每一组内的数据分别进行直接插入排序再得到一个结果。
5. 对于第四步中得到的这个结果再选定一个整数gap=1，也就是将这组数据分成了1组，对这一组数据进行直接插入排序得到最终排序结果。
   

注意： 这里的gap为增量数组，也就是随机设定的这几个数字都必须降序且为素数，且最后一个值一定为1即可。
下图为一个希尔排序的示例：

3.3.2 实现

希尔排序实现代码如下所示：

import java.util.Arrays;
public class TestSort {//这个函数其实就是一个每组的直接插入排序了public static void shell(int[] array,int gap){for (int i = gap; i < array.length; i++) {int tmp = array[i];int j = i-gap;for (; j >= 0; j=j-gap) {//如果这里是一个大于等于号，此时这个排序就不稳定了if(array[j] > tmp){array[j+gap] = array[j];}else {break;}}array[j+gap] = tmp;}}public static void shellSort(int[] array){int[] drr = {5,3,1};//增量数组：这几个数字都必须为素数，且最后一个值一定为1即可for (int i = 0; i < drr.length; i++) {shell(array,drr[i]);}}public static void main(String[] args) {int[] array = {10,3,2,7,19,78,65,127};System.out.println(Arrays.toString(array));shellSort(array);System.out.println(Arrays.toString(array));}
}

3.3.3 性能分析

由于gap取值不唯一，希尔排序的时间复杂度不好计算，因此在希尔排序的时间复杂度不固定，所以下表中的最好和平均时间复杂度均为估算。

时间复杂度			空间复杂度
最好	平均	最坏
O(n^1.3)	O(n^1.5)	O(n^2)	O(1)
数据有序		比较难构造

稳定性： 不稳定。
特点：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样排序速度就会很快。这样整体而言，可以达到优化的效果。

4 选择排序

4.1 选择排序

4.1.1 思想

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。即：

1. 在待排序的一组数据中，选出最小（最大）的一个数与第一个位置的数交换。
   例：如下图所示序列【12，5，9，16，6】，此时i是12，j是5，j比i小，j、i所指的数字互换，得到[5,12,9,16,6]；
   然后j+1遇到j比i小的情况时，j、i所指的数字就互换，直到j指向最后一个数字结束第一轮选择排序，这里得到的结果还是[5,12,9,16,6]。
2. 然后在剩下的数中，再找最小（最大）的数与第二个位置的数交换位置。
   例：此时序列变为[5,12,9,16,6]，则此时i是12，j是9，j比i小，j、i所指的数字互换，得到[5,9,12,16,6]；
   然后j+1遇到j比i小的情况时，j、i所指的数字就互换，直到j指向最后一个数字结束第一轮选择排序，这里得到的结果是[5,6,1216,9]。
3. 依次类推直到第 n-1 个元素与第 n 个元素交换位置，选择排序结束。

4.1.2 实现

选择排序实现代码如下所示：

import java.util.Arrays;
public class TestSort {/** 选择排序:* 时间复杂度：O(n^2)* 空间复杂度：O(1)* 稳定性：不稳定* */public static void selectSort(int[] array){for (int i = 0; i < array.length-1; i++) {for (int j = i+1; j <array.length; j++) {if(array[j] < array[i]){int tmp = array[j];array[j] = array[i];array[i] = tmp;}}}}public static void main(String[] args) {int[] array = {10,3,2,7,19,78,65,127};System.out.println(Arrays.toString(array));selectSort(array);System.out.println(Arrays.toString(array));}
}

4.1.3 性能分析

时间复杂度	空间复杂度
O(n^2)	O(1)

稳定性： 不稳定。

int[] a = { 9, 2, 5a, 7, 4, 3, 6, 5b };
// 交换中该情况无法识别，保证 5a 还在 5b 前边

4.1.4 双向选择排序

思想： 每一次从无序区间选出最小 + 最大的元素，存放在无序区间的最前和最后，直到全部待排序的数据元素排完。
双向选择排序实现代码如下所示：

public static void selectSortOP(int[] array) {int low = 0;int high = array.length - 1;// [low, high] 表示整个无序区间// 无序区间内只有一个数也可以停止排序了while (low <= high) {int min = low;int max = low;for (int i = low + 1; i <= max; i++) {if (array[i] < array[min]) {min = i;}if (array[i] > array[max]) {max = i;}}swap(array, min, low);// 见下面例子讲解if (max == low) {max = min;}swap(array, max, high);}
}
private void swap(int[] array, int i, int j) {int t = array[i];array[i] = array[j];array[j] = t;
}

理解：

1. array = { 9, 5, 2, 7, 3, 6, 8 }; // 交换之前
   // low = 0; high = 6
   // max = 0; min = 2
2. array = { 2, 5, 9, 7, 3, 6, 8 }; // 将最小的交换到无序区间的最开始后
   // max = 0，但实际上最大的数已经不在 0 位置，而是被交换到 min 即 2 位置了
   // 所以需要让 max = min 即 max = 2
3. array = { 2, 5, 8, 7, 3, 6, 9 }; // 将最大的交换到无序区间的最结尾后

4.2 堆排序

4.2.1 思想

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意： 排升序要建大堆；排降序要建小堆。
具体思想可借助下图和链接https://blog.csdn.net/weixin_51312723/article/details/134121250进行理解：

4.2.2 实现

堆排序实现代码在链接https://blog.csdn.net/weixin_51312723/article/details/134121250中的3.7.2节详见。

4.2.3 性能分析

时间复杂度	空间复杂度
O(nlog2(n))	O(1)

稳定性： 不稳定。

5 交换排序

5.1 冒泡排序

5.1.1 思想

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序。

1. 从第一个下标开始，也就是0，比较第一个和第二个元素，如果第一个元素比第二个元素大，那就交换两者。
   然后比较第二个元素和第三个元素，如果两者也不是升序，那交换两者，一直比较和交换，直到最后。
2. 之后就是不断迭代上述步骤直到数组整体有序即可。

5.1.2 实现

public static void bubbleSort(int[] array) { for (int i = 0; i < array.length - 1; i++) { boolean isSorted = true; for (int j = 0; j < array.length - i - 1; j++) { // 相等不交换，保证稳定性if (array[j] > array[j + 1]) { swap(array, j, j + 1); isSorted = false; } } if (isSorted) { break; } }}

5.1.3 性能分析

时间复杂度			空间复杂度
最好	平均	最坏
O(n)	O(n^2)	O(n^2)	O(1)
数据有序		数据逆序

稳定性： 稳定。

5.2 快速排序

5.2.1 思想

快速排序思想总览：

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 = 1 ，代表已经有序，或者小区间的长度 = 0，代表没有数据。

选择基准的方法：

1. 选择边上（左或者右）：例如最简单的选择基准值的方式，选择 array[left] 作为基准值。
2. 随机选取基准法：就是随机找到后边的一个下标，然后和low下标的数据进行交换，最后以low下标交换后的值作为基准。
3. 几数取中（例如三数取中）法：array[left], array[mid], array[right] 大小是中间的为基准值。

具体通过选择边上（左或者右）法找基准的过程借助下图进行理解：

5.2.2 实现

快速排序实现代码如下所示：

import java.util.Arrays;
public class TestSort {/** 快速排序:* 时间复杂度：最好：O(n*log2^(n)) 最坏（有序的情况）：O(n^2)* 所以在有序的情况下我们就要优化这个快速排序！---优化方法是：使用三数取中找基准法进行优化* 空间复杂度：O(log2^(n))* 稳定性：不稳定* * 分治思想：什么时候效率最高？* 答：每次把待排序序列均匀的划分。* * 调JVM的栈参数* * 快速排序的递归和非递归 及递归的优化方式* *///找基准-选择边上（左或者右）法//最简单的选择基准值的方式，选择 array[left] 作为基准值public static int pivot(int[] array,int start,int end){int tmp = array[start];while(start < end){while(start < end && array[end] >= tmp){end--;}array[start] = array[end];//把数据赋值给startwhile(start < end && array[start] <= tmp){start++;}//把start下标的值给endarray[end] = array[start];}array[start] = tmp;return start;}//三数取中找基准法public static void swap(int[] array,int k,int i){int tmp = array[k];array[k] = array[i];array[i] = tmp;}public static void medianOfThree(int[] array,int low,int high){int mid = (low+high)/2;//array[mid] <= array[low] <= array[high]if(array[low] < array[mid]){swap(array,low,mid);} //array[mid] <= array[low]if(array[low] > array[high]){swap(array,low,high);} // array[low] <= array[high]if(array[mid] > array[high]){swap(array,mid,high);} // array[mid] <= array[high]}public static void insertSortBount(int[] array,int low,int high){for (int i = low+1; i <= high; i++) {int tmp = array[i];int j = i-1;for (; j >= low; j--) {//如果这里是一个大于等于号，此时这个排序就不稳定了if(array[j] > tmp){array[j+1] = array[j];}else {break;}}array[j+1] = tmp;}}public static void quick(int[] array,int low,int high){if(low >= high) return;//if(high - low +1 <= 50){//使用插入排序//insertSortBount(array,low,high);//return;//记者这里一定要return，这里说明这个区间范围有序了，直接结束// }//if(low < high){medianOfThree(array,low,high);//优化方法代码//这个之前进行一个优化int piv = pivot(array,low,high);quick(array,low,piv-1);quick(array,piv+1,high);}}//递归public static void quickSort(int[] array){long startTime = System.currentTimeMillis();//这里时间的单位是毫秒msquick(array,0,array.length-1);long endTime = System.currentTimeMillis();System.out.println(endTime- startTime);}//非递归/** 和递归是一样的* 时间复杂度：最好：O(n*log2^(n))* 空间复杂度：O(n)   最好空间复杂度：log2^(n)* */public static void quickSort1(int[] array){Stack<Integer> stack = new Stack<>();int low = 0;int high = array.length-1;int piv = pivot(array,low,high);if(piv > low+1){stack.push(low);stack.push(piv-1);}if(piv < high-1){stack.push(piv+1);stack.push(high);}while (!stack.empty()) {high = stack.pop();low = stack.pop();piv = pivot(array,low,high);if(piv > low+1){stack.push(low);stack.push(piv-1);}if(piv < high-1){stack.push(piv+1);stack.push(high);}}}//测试一下优化后的快速排100000个数据所需的时间public static void main(String[] args) {int[] array = new int[1_0000];Random random = new Random();for(int i = 0; i < array.length; i++){//array[i] = i;array[i] = random.nextInt(1_0000);}long startTime = System.currentTimeMillis();quickSort(array);long endTime = System.currentTimeMillis();System.out.println(endTime-startTime);System.out.println(Arrays.toString(array));}public static void main1(String[] args) {int[] array = {10,3,2,7,19,78,65,127};System.out.println(Arrays.toString(array));quickSort(array);System.out.println(Arrays.toString(array));}
}

5.2.3 性能分析

时间复杂度		空间复杂度
最好	最坏
O(n*log2^(n))	O(n^2)	O(log2^(n))
	数据有序

求递归的时间复杂度： 递归次数每一次遍历次数。
这里的递归次数：log2 ^ n,也就是二叉树的高度；且每一次都要遍历n次；所以此时时间复杂度为 O(nlog2^(n))。
稳定性： 不稳定。
总结：

1. 选择基准值很重要，通常使用几数取中法。
2. pivot 过程（使得小的数在左，大的数在右）把和基准值相等的数也选择出来。
3. 分治处理左右两个小区间，待小区间小于一个阈值时（例如 48），使用直接插入排序对快速排序进行优化。插入排序越有序越快

6 归并排序

6.1归并排序

6.1.1 思想

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

6.1.2 实现

归并排序实现代码如下所示：

import java.util.Arrays;
import java.util.Random;
import java.util.Stack;public class TestSort {/** 归并排序* 稳定性：稳定* 不管好坏时间复杂度都是：O(n*log2^(n))* 空间复杂度：O(n)** 堆排 归并 不管好坏时间复杂度都是：O(n*log2^(n))* 快排最坏情况下时间复杂度是O(n^2)* */public static void merge(int[] array,int start,int mid,int end){int s1 = start;//int e1= mid;int s2 = mid+1;//int e2 = end;int[] tmp = new int[end-start+1];int k = 0;//tmp数组的下标while(s1 <= mid && s2 <= end){if(array[s1] <= array[s2]){tmp[k++] = array[s1++];}else{tmp[k++] = array[s2++];}}//有可能第一个段还有数据 有可能第二个段也有数据while(s1 <= mid){tmp[k++] = array[s1++];}while(s2 <= end){tmp[k++] = array[s2++];}for (int i = 0; i < tmp.length ; i++) {array[i+start] = 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 mergeSort(int[] array){mergeSortInternal(array,0,array.length-1);}//非递归public static void merge1(int[] array,int gap){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;int[] tmp = new int[array.length];int k = 0;//下标//当有两个归并段的时候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;}//退出上面循环后，那么把s1段内的数据给拷贝下来，因为 有可能e1已经越界了while (s1 <= e1) {tmp[k++] = array[s1++];}for (int i = 0; i < tmp.length; i++) {array[i] = tmp[i];}}public static void mergeSort2(int[] array){for (int i = 1; i < array.length; i*=2) {merge1(array,i);}}public static void main(String[] args) {int[] array = new int[1_0000];Random random = new Random();for(int i = 0; i < array.length; i++){//array[i] = i;array[i] = random.nextInt(1_0000);}long startTime = System.currentTimeMillis();mergeSort(array);long endTime = System.currentTimeMillis();System.out.println(endTime-startTime);System.out.println(Arrays.toString(array));}
}

6.1.3 性能分析

时间复杂度	空间复杂度
O(nlog2^(n))	O(n)

稳定性： 稳定。
优化总结： 在排序过程中重复利用两个数组，减少元素的复制过程。

7 海量数据的排序问题

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

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

8 总结

排序方法		最好时间复杂度	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
交换排序	冒泡排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
插入排序	直接插入排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
插入排序	折半插入排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定
选择排序	选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定
插入排序	希尔排序	O(n)	O(n^1.3)	O(n^2)	O(1)	不稳定
选择排序	堆排序	O(nlog2(n))	O(nlog2(n))	O(nlog2(n))	O(1)	不稳定
交换排序	快速排序	O(nlog2(n))	O(nlog2(n))	O(n^2)	O(log2^(n)) ~ O(n)	不稳定
归并排序	归并排序	O(nlog2(n))	O(nlog2(n))	O(nlog2(n))	O(n)	稳定

9 其他非基于比较的排序（了解）

1. 计数排序
2. 基数排序
3. 桶排序