技术分享之八大排序算法（均已以升序为例）

一、排序名称

内部排序：指待排序列完全存放在内存中所进行的排序过程，适合不太大的元素序列。其中快速排序的是目前排序方法中被认为是最好的方法。

1、插入排序：直接插入排序、(shell)希尔排序

2、交换排序：冒泡排序、快速排序

3、选择排序：简单选择排序、堆排序

4、归并排序

5、基数排序

外部排序：指的是大文件的排序，即待排序的记录存储在外存储器(硬盘…)上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。

例如：将原文件分解成多个能够一次性装入内存的部分分别把每一部分调入内存完成排序。然后，对已经排序的子文件进行归并排序。内存才2G，外存有1000G待排序文件 = 500个 x 2G，然后每2G转入内存进行排序，排完序写入外存，最后将500个排好序的文件进行归并排序。

二、性能元素

1、稳定性

（1）通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj，Ai原来在位置前，排序后Ai还是要在Aj位置前。例如：{ 2 5 3 7 10 7 9} —> { 2 3 5 7 7 9 10} ，一次排序后，红色的"7"还是在绿色的"7"前面。

（2）稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序在高位也相同时是不会改变的。

2、时间复杂度 T(n)=O(f(n))

（1）算法的时间复杂度O(n)是一个问题规模n函数，没有严格的定义，它定量描述了该算法的运行所需要的时间。衡量一个算法的效率，如果以每条代码的实际执行次数，虽然精确，但十分烦琐。因此人们设计了用数量级的方法来衡量算法效率，如甲程序的执行次数为2n(n为数据量个数),乙为 3n+2,则当 n 很大时,认为甲乙是等数量级的,是等效率的

（2）时间频度不同(一个算法中的语句执行次数称为语句频度或时间频度。记为T(n))，但时间复杂度可能相同。如：T(n)=n^2+3n与T(n)=n^2+4n它们的频度不同，但时间复杂度相同，都为O(n^2)。

（3）时间复杂度比较简单的计算方法是：看看有几重for循环，没有循环时间复杂度为O(1)，只有一重则时间复杂度为O(n)，二重则为O(n^2)，依此类推，如果有二分则为O(logn)，二分例如快速幂、二分查找，如果一个for循环套一个二分，那么时间复杂度则为O(nlogn)。

3、空间复杂度 S(n)=O(f(n))

（1）它也是问题规模n的函数，S(n)定义为一个算法在运行过程中临时占用辅助存储空间大小的量度。

（2）算法的空间复杂度一般也以数量级的形式给出。

当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；

当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为O(log2n)；

当一个算法的空间复杂度与n成线性比例关系时，可表示为O(n)。

三、性能总结

四、分别介绍

1、简单选择排序

思想：

一句话概括就是依次按位置挑选出适合此位置的元素来填充。

过程：

（1）暂定第一个元素为最小元素，往后遍历，逐个与最小元素比较，若发现更小者，与先前的"最小元素"交换位置。达到更新最小元素的目的。

（2）一趟遍历完成后，能确保刚刚完成的这一趟遍历中，最的小元素已经放置在前方了。然后缩小排序范围，新一趟排序从数组的第二个元素开始。

（3）在新一轮排序中重复第1、2步骤，直到范围不能缩小为止，排序完成。

示例：

以下为选择排序的存储状态，其中大括号内为无序区，大括号外为有序序列：

初始序列：{49 27 65 97 76 12 38}

　　第1趟：12与49索引交换：12 {27 65 97 76 49 38}

　　第2趟：27不动　： 12 27 {65 97 76 49 38}

　　第3趟：65与38索引交换：12 27 38 {97 76 49 65}

　　第4趟：97与49索引交换：12 27 38 49 {76 97 65}

　　第5趟：76与65索引交换：12 27 38 49 65 {97 76}

　　第6趟：97与76索引交换：12 27 38 49 65 76 97 完成

核心代码：

2、冒泡排序

思想：

一句话概括就是将待排序的元素看作是竖着排列的“气泡”，较小的元素比较轻，浮在上面，较大的元素往下沉。

过程：

（1）在一趟遍历中，不断地对相邻的两个元素进行排序，小的在前大的在后，这样会造成大值不断沉底的效果，当一趟遍历完成时，最大的元素会被排在后方正确的位置上。

（2）然后缩小排序范围，即去掉最后方位置正确的元素，对前方数组进行新一轮遍历，重复第1步骤。直到范围不能缩小为止，排序完成。

示例：

以下为选择排序的存储状态，其中大括号内为无序区，大括号外为有序序列：

初始序列：{49 27 65 97 76 12 38}

　　第1趟：97沉底：{ 49 27 65 76 12 38} 97

　　第2趟：76沉底：{ 49 27 65 12 38 } 76 97

　　第3趟：65沉底：{ 49 27 12 38 } 65 76 97

　　第4趟：49沉底：{ 27 12 38 } 49 65 76 97

　　第5趟：38沉底：{ 27 12 } 38 49 65 76 97

　　第6趟：27沉底：{ 12 } 27 38 49 65 76 97

第7趟：12沉底：12 27 38 49 65 76 97 完成

核心代码：

3、直接插入排序

思想：

插入排序是从一个乱序的数组中依次取值，插入到一个已经排好序的数组中，比较的两个记录跨度为1。可以想象一下打扑克牌插牌时的情景。这看起来好像要两个数组才能完成，但如果只想在同一个数组内排序，也是可以的。此时需要想象出两个区域：前方有序区和后方乱序区。

某些情况下效率很高：1、记录本身基本有序 2、记录数比较少

过程：

（1）分区。开始时前方有序区只有一个元素，就是数组的第一个元素。然后把从第二个元素开始直到结尾的数组作为乱序区。

（2）从乱序区取第一个元素，把它正确插入到前方有序区中。把它与前方有序区的最后一个元素比较，亦即与它的前一个元素比较。

如果比前一个元素要大，则不需要交换，这时有序区扩充一格，乱序区往后缩减一格，相当于直接拼在有序区末尾。
如果和前一个元素相等，则继续和前二元素比较、再和前三元素比较......如果往前遍历到头了，发现前方所有元素值都一样，那也可以不需要交换，这时有序区扩充一格，乱序区往后缩减一格，相当于直接拼在有序区末尾。
如果比前一个元素小，则交换它们的位置。交换完后，继续比较取出元素和它此时的前一个元素，若更小就交换，若相等就比较前一个，直到遍历完成。
至此，把乱序区第一个元素正确插入到前方有序区中。

（3）往后缩小乱序区范围，继续取缩小范围后的第一个元素，重复第2步骤。直到范围不能缩小为止，排序完成。

示例：

以下为选择排序的存储状态，其中大括号内为无序区，大括号外为有序序列：

初始序列：{49 27 65 97 76 12 38}

　　第1趟：无序区的27添加到有序区49的前面 {27 49} { 65 97 76 12 38}

　　第2趟：无序区的65添加到有序区49的后面 {27 49 65} { 97 76 12 38}

　　第3趟：无序区的97添加到有序区65的后面 {27 49 65 97} { 76 12 38}

　　第4趟：无序区的65添加到有序区97的前面,49的后面 {27 49 65 76 97} { 12 38}

　　第5趟：无序区的76添加到有序区97的前面,65的后面 {12 27 49 65 76 97} { 38}

　　第6趟：无序区的12添加到到有序区27的前面 {12 27 49 65 76 97} {38}

第7趟：无序区的38添加到到有序区49的前面,27的后面 {12 27 38 49 65 76 97} 完成

核心代码：

4、快速排序

思想：

通过一趟排序将要排序的数据分割成独立的两部分：分割点左边都是比它小的数，右边都是比它大的数。然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

过程：

示例：

上图中，演示了快速排序的处理过程：

初始状态为一组无序的数组：2、4、5、1、3。

经过以上操作步骤后，完成了第一次的排序，得到新的数组：1、2、5、4、3。

新的数组中，以2为分割点，左边都是比2小的数，右边都是比2大的数。

因为2已经在数组中找到了合适的位置，所以不用再动。

2左边的数组只有一个元素1，所以显然不用再排序，位置也被确定。（注：这种情况时，left指针和right指针显然是重合的。因此在代码中，我们可以通过设置判定条件left必须小于right，如果不满足，则不用排序了）。

而对于2右边的数组5、4、3，设置left指向5，right指向3，开始继续重复图中的一、二、三、四步骤，对新的数组进行排序

核心代码：

5、堆排序

堆：堆是一棵顺序存储的完全二叉树。

其中每个结点的关键字都不大于其孩子结点的关键字，这样的堆称为小根堆。

其中每个结点的关键字都不小于其孩子结点的关键字，这样的堆称为大根堆。

举例来说，对于n个元素的序列{R0, R1, ... , Rn}当且仅当满足下列关系之一时，称之为堆：

(1) Ri <= R2i+1 且 Ri <= R2i+2 (小根堆)

(2) Ri >= R2i+1 且 Ri >= R2i+2 (大根堆)

其中i=1,2,…,n/2向下取整;

思想（最大堆进行升序排序）：

① 初始化堆：将数列a[1...n]构造成最大堆。

② 交换数据：将a[1]和a[n]交换，使a[n]是a[1...n]中的最大值；然后将a[1...n-1]重新调整为最大堆。接着，将a[1]和a[n-1]交换，使a[n-1]是a[1...n-1]中的最大值；然后将a[1...n-2]重新调整为最大值。依次类推，直到整个数列都是有序的。整个过程就是：创建堆—堆排序—创建堆—堆排序......堆排序（Heap Sort）只需要一个记录元素大小的辅助空间（供交换用），每个待排序的记录仅占有一个存储空间。

过程：

（1）根据初始数组去构造初始堆（构建一个完全二叉树，保证所有的父结点都比它的孩子结点数值大），按层倒着选择非叶节点去比较。

（2）每次交换第一个和最后一个元素，输出最后一个元素（最大值），然后把剩下元素重新调整为大根堆。当输出完最后一个元素后，这个数组已经是按照从小到大的顺序排列了。

示例：

（1)构建堆

无序序列{ 1 , 3, 4, 5, 2, 6, 9, 7, 8, 0}