八大排序算法总结

常见的排序算法有：冒泡排序、快速排序、插入排序、希尔排序、选择排序、堆排序、归并排序、基数排序等。本文将依次介绍上述八大排序算法。
图解

1. 冒泡排序

它的基本思想是

重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

冒泡排序算法的原理如下：
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3、针对所有的元素重复以上的步骤，除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

举例说明：6、3、8、2、9、1
第一趟排序：
1、6和3比较，6大于3，交换位置： 3 6 8 2 9 1
2、6和8比较，6小于8，不交换位置 3 6 8 2 9 1
3、8和2比较，8大于2，交换位置： 3 6 2 8 9 1
4、8和9比较，8小于9，不交换位置 3 6 2 8 9 1
5、9和1比较：9大于1，交换位置： 3 6 2 8 1 9
第一趟进行了5次比较， 排序结果： 3 6 2 8 1 9

第二趟排序：
1、3和6比较，3小于6，不交换位置 3 6 2 8 1 9
2、6和2比较，6大于2，交换位置： 3 2 6 8 1 9
3、6和8比较，6大于8，不交换位置 3 2 6 8 1 9
4、8和1比较，8大于1，交换位置： 3 2 6 1 8 9
第二趟进行了4次比较， 排序结果： 3 2 6 1 8 9

第三趟排序：
1、3和2比较，3大于2，交换位置： 2 3 6 1 8 9
2、3和6比较，3小于6，不交换位置 2 3 6 1 8 9
3、6和1比较，6大于1，交换位置： 2 3 1 6 8 9
第三趟进行了3次比较， 排序结果： 2 3 1 6 8 9

第四趟排序：
1、2和3比较，2小于3，不交换位置 2 3 1 6 8 9
2、3和1比较，3大于1，交换位置： 2 1 3 6 8 9
第四趟进行了2次比较， 排序结果： 2 1 3 6 8 9

第五趟排序：
1、2和1比较，2大于1，交换位置： 1 2 3 6 8 9
第五趟进行了1次比较， 排序结果： 1 2 3 6 8 9

最终结果：1 2 3 6 8 9

时间复杂度

若 n 个数据的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数 C 达到最小值：$$C_{min}=n-1$$
所以，冒泡排序最好的时间复杂度为 O(n) 。

若 n 个数据是反序的，需要进行 n-1 趟排序。每趟排序要进行 n-i 次关键字的比较(1≤i≤n-1)。在这种情况下，比较次数 C 达到最大值：
$$C_{max}=(n-1)+(n-2)+\cdot \cdot \cdot +1=\frac{n(n-1)}{2}=O(n^2)$$
所以，冒泡排序的最坏时间复杂度为 O(n^2) 。

综上，因此冒泡排序总的平均时间复杂度为 O(n^2) 。

稳定性

从上述算法描述里，我们可以很容易的知道：
冒泡排序是稳定的

2. 快速排序

它的基本思想是

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，以此达到整个数据变成有序序列。

首先是第一趟排序(第一次划分)：
要把比第一个数49小的数放到这个49的左边，剩下的放到右边。
1、从右往左找比49小的数，第一个是27，然后27和49调换位置，
变成27、38、65、97、76、13、49、49
2、从左往右找比49大的数，第一个是65，然后65和49调换位置，
变成27、38、49、97、76、13、65、49
之后就是上面两步操作的循环，
变成27、38、13、97、76、49、65、49
变成27、38、13、49、76、97、65、49
第一趟排序完成

接着将数据分成49左边和49右边两个部分，分别对两个部分进行上述操作，先进行左边部分排序，
变成13、27、38、49、76、97、65、49
此时左边部分已经不能再继续分组了，也就是说左边部分排序完成

然后进行右边部分的排序，也是按照上述操作，
变成13、27、38、49、49、65、76、97
右边第一趟排序完成

之后的以此类推，
变成13、27、38、49、49、65、76、97
排序结束

时间复杂度

快速排序的每一次划分把一个问题分解成两个子问题
每一场划分需要对整个数组扫描一遍，做n次比较
$$时间T(n)=2T(\frac{n}{2})+n$$
$$T(n)=2(2T(\frac{n}{4})+\frac{n}{2})+n=4T(\frac{n}{4})+2n$$
$$T(n)=4(2T(\frac{n}{8})+\frac{n}{4})+2n=8T(\frac{n}{8})+3n$$
$$而T(1)=0$$
$$T(n)=nT(1)+lo{g}_2(n)\ast n=O(n\ast lo{g}_2(n))$$

稳定性

快速排序是不稳定的
例如（5，3A，6，3B）排序之后是（3B，3A，5，6）

3. 插入排序

其基本思想是

把待排序的记录按其大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。

例如,已知待排序的一组记录是：
60,71,49,11,24,3,66
假设在排序过程中，前3个记录已按关键码值递增的次序重新排列，构成一个有序序列：
49,60,71
将待排序记录中的第4个记录（即11）插入上述有序序列，以得到一个新的含4个记录的有序序列。首先，应找到11的插入位置，再进行插入。可以讲11放入数组的第一个单元r[0]中，这个单元称为监视哨，然后从71起从右到左查找，11小于71，将71右移一个位置，11小于60，又将60右移一个位置，11小于49，又再将49右移一个位置，这时再将11与r[0]的值比较，11≥r[0]，它的插入位置就是r[1]。假设11大于第一个值r[1]。它的插入位置应该在r[1]和r[2]之间，由于60已经右移了，留出来的位置正好留给11.后面的记录依照同样的方法逐个插入到该有序序列中。若记录数n,需进行n-1趟排序，才能完成。

时间复杂度

插入排序的时间复杂度与冒泡排序类似。
若 n 个数据的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数 C 达到最小值：$$C_{min}=n-1$$
所以，插入排序最好的时间复杂度为 O(n) 。

若 n 个数据是反序的，需要进行 n-1 趟排序。每趟排序要进行 n-i 次关键字的比较(1≤i≤n-1)。在这种情况下，比较次数 C 达到最大值：
$$C_{max}=(n-1)+(n-2)+\cdot \cdot \cdot +1=\frac{n(n-1)}{2}=O(n^2)$$
所以，插入排序的最坏时间复杂度为 O(n^2) 。

综上，因此插入排序总的平均时间复杂度为 O(n^2) 。

稳定性

类似于冒泡排序，插入排序也是稳定的

4. 希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

时间复杂度

希尔排序平均时间复杂度为 O(n^1.3) 。
具体怎么来的我还没理解。

稳定性

由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不稳定的。

5. 选择排序

它的工作原理是：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

时间复杂度

选择排序的时间复杂度与冒泡排序类似。
若 n 个数据的初始状态是正序的，一趟扫描即可完成排序。所需的关键字比较次数 C 达到最小值：$$C_{min}=n-1$$
所以，选择排序最好的时间复杂度为 O(n) 。

若 n 个数据是反序的，需要进行 n-1 趟排序。每趟排序要进行 n-i 次关键字的比较(1≤i≤n-1)。在这种情况下，比较次数 C 达到最大值：
$$C_{max}=(n-1)+(n-2)+\cdot \cdot \cdot +1=\frac{n(n-1)}{2}=O(n^2)$$
所以，选择排序的最坏时间复杂度为 O(n^2) 。

综上，因此选择排序总的平均时间复杂度为 O(n^2) 。

稳定性

针对排序算法，我们举出一个实例，序列5A，8，5B，2，9， 这个在执行选择排序的时候，第一遍，肯定会将array[0]=5A，交换到2所在的位置，也就是2，8，5B，5A，9，那么很显然，之后的排序我们就会发现，array[2]中的5B会出现在原先的5A之前，所以选择排序是不稳定的排序。

6. 堆排序

堆排序的基本思路：

1.将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆;
2.将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端;
3.重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

时间复杂度

堆排序平均时间复杂度为
$$O(n\ast lo{g}_2(n))$$
具体怎么来的我还没理解。

稳定性

堆排序是不稳定的算法，它不满足稳定算法的定义。它在交换数据的时候，是比较父结点和子节点之间的数据，所以，即便是存在两个数值相等的兄弟节点，它们的相对顺序在排序也可能发生变化。

7. 归并排序

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

分而治之

治阶段

时间复杂度

归并排序的时间复杂度类似于快速排序
归并排序的每一次分阶段把一个问题分解成两个子问题
每一场治阶段需要对整个数组扫描一遍，做n次比较
$$时间T(n)=2T(\frac{n}{2})+n$$
$$T(n)=2(2T(\frac{n}{4})+\frac{n}{2})+n=4T(\frac{n}{4})+2n$$
$$T(n)=4(2T(\frac{n}{8})+\frac{n}{4})+2n=8T(\frac{n}{8})+3n$$
$$而T(1)=0$$
$$T(n)=nT(1)+lo{g}_2(n)\ast n=O(n\ast lo{g}_2(n))$$

稳定性

从上述算法描述里，我们可以很容易的知道：
冒泡排序是稳定的
例如，在治阶段，有4A，5和4B，6，那么左边数组的4A会先进入新数组temp，变成4A，4B，5，6。

8. 基数排序

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。
有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

时间复杂度

分配的时间复杂度为O（n），n指n个数
收集的的时间复杂度为O（radix），radix指每一位的范围，一般是0-9，所以radix一般为10
分配和收集共需要distance趟，distance指最大的元素有d位
所以基数排序的时间复杂度为O(d(n+r))

稳定性

从上述算法描述里，我们可以很容易的知道：
基数排序是稳定的
因为放入桶的时候，相同的数的相对位置不变。