Java实现的几个常用排序算法 广州疯狂JAVA培训

排序算法应用性很广泛，近期自己总结了一下他的作用，并自己简单地实现了一遍，特此记录下来，为以后复习留点材料。下面逐一看看经典的排序算法：

1. 插入排序

插入排序的基本思想是在遍历数组的过程中，假设在序号i 之前的元素即[0i-1] 都已经排好序，本趟需要找到i 对应的元素x 的正确位置k ,并且在寻找这个位置k 的过程中逐个将比较过的元素往后移一位，为元素x "腾位置",最后将k 对应的元素值赋为x ,插入排序也是根据排序的特性来命名的。

以下是一个实例，红色 标记的数字为插入的数字，被划掉的数字是未参与此次排序的元素，红色 标记的数字与被划掉数字之间的元素为逐个向后移动的元素，比如第二趟参与排序的元素为[11, 31, 12] ,需要插入的元素为12 ,但是12 当前并没有处于正确的位置，于是我们需要依次与前面的元素31 、11 做比较，一边比较一边移动比较过的元素，直到找到第一个比12 小的元素11 时停止比较，此时31 对应的索引1 则是12 需要插入的位置。

初始： [11, 31, 12, 5, 34, 30, 26, 38, 36, 18]

第一趟：[11, 31 , 12, 5, 34, 30, 26, 38, 36, 18] （无移动的元素）

第二趟：[11, 12 , 31, 5, 34, 30, 26, 38, 36, 18] （31 向后移动）

第三趟：[5 , 11, 12, 31, 34, 30, 26, 38, 36, 18] （11, 12, 31 皆向后移动）

第四趟：[5, 11, 12, 31, 34 , 30, 26, 38, 36, 18] （无移动的元素）

第五趟：[5, 11, 12, 30 , 31, 34, 26, 38, 36, 18] （31, 34 向后移动）

第六趟：[5, 11, 12, 26 , 30, 31, 34, 38, 36, 18] （30, 31, 34 向后移动）

第七趟：[5, 11, 12, 26, 30, 31, 34, 38 , 36, 18] （无移动的元素）

第八趟：[5, 11, 12, 26, 30, 31, 34, 36 , 38, 18] （38 向后移动）

第九趟：[5, 11, 12, 18 , 26, 30, 31, 34, 36, 38] （26, 30, 31, 34, 36, 38 向后移动）

插入排序会优于选择排序，理由是它在排序过程中能够利用前部分数组元素已经排好序的一个优势，有效地减少一些比较的次数，当然这种优势得看数组的初始顺序如何，最坏的情况下（给定的数组恰好为倒序）插入排序需要比较和移动的次数将会等于1 + 2 + 3…+ n = n * （n + 1） / 2 ,这种极端情况下，插入排序的效率甚至比选择排序更差。因此插入排序是一个不稳定的排序方法，插入效率与数组初始顺序息息相关。一般情况下，插入排序的时间复杂度和空间复杂度分别为O（n2 ） 和O（1） .

2. 希尔排序

希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组"分而治之",划分为若干个小的数组，以gap 来划分，比如数组[1, 2, 3, 4, 5, 6, 7, 8] ,如果以gap = 2 来划分，可以分为[1, 3, 5, 7] 和[2, 4, 6, 8] 两个数组（对应的，如gap = 3 ,则划分的数组为：[1, 4, 7] 、[2, 5, 8] 、[3, 6] ）然后分别对划分出来的数组进行插入排序，待各个子数组排序完毕之后再减小gap 值重复进行之前的步骤，直至gap = 1 ,即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题。希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大，数据量小的时候建议直接使用插入排序就好了。

3. 选择排序

选择排序的基本思想是遍历数组的过程中，以i 代表当前需要排序的序号，则需要在剩余的[i…n-1] 中找出其中的最小值，然后将找到的最小值与i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。举个实例来看看：

初始：[38, 17, 16, 16, 7, 31, 39, 32, 2, 11]

i = 0: [2 , 17, 16, 16, 7, 31, 39, 32, 38 , 11] （0th [38]<->8th [2]）

i = 1: [2, 7 , 16, 16, 17 , 31, 39, 32, 38, 11] （1st [38]<->4th [17]）

i = 2: [2, 7, 11 , 16, 17, 31, 39, 32, 38, 16 ] （2nd [11]<->9th [16]）

i = 3: [2, 7, 11, 16, 17, 31, 39, 32, 38, 16] （ 无需交换）

i = 4: [2, 7, 11, 16, 16 , 31, 39, 32, 38, 17 ] （4th [17]<->9th [16]）

i = 5: [2, 7, 11, 16, 16, 17 , 39, 32, 38, 31 ] （5th [31]<->9th [17]）

i = 6: [2, 7, 11, 16, 16, 17, 31 , 32, 38, 39 ] （6th [39]<->9th [31]）

i = 7: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] （ 无需交换）

i = 8: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] （ 无需交换）

i = 9: [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] （ 无需交换）

由例子可以看出，选择排序随着排序的进行（i 逐渐增大），比较的次数会越来越少，但是不论数组初始是否有序，选择排序都会从i 至数组末尾进行一次选择比较，所以给定长度的数组，选择排序的比较次数是固定的：1 + 2 + 3 + … + n = n * （n + 1） / 2 ,而交换的次数则跟初始数组的顺序有关，如果初始数组顺序为随机，则在最坏情况下，数组元素将会交换n 次，最好的情况下则可能0 次（数组本身即为有序）。由此可以推出，选择排序的时间复杂度和空间复杂度分别为O（n2 ） 和O（1） （选择排序只需要一个额外空间用于数组元素交换）。

4. 归并排序

归并排序采用的是递归来实现，属于"分而治之",将目标数组从中间一分为二，之后分别对这两个数组进行排序，排序完毕之后再将排好序的两个数组"归并"到一起，归并排序最重要的也就是这个"归并"的过程，归并的过程中需要额外的跟需要归并的两个数组长度一致的空间，比如需要规定的数组分别为：[3, 6, 8, 11] 和[1, 3, 12, 15] （虽然逻辑上被划为为两个数组，但实际上这些元素还是位于原来数组中的，只是通过一些index 将其划分成两个数组，原数组为[3, 6, 8, 11, 1, 3, 12, 15 ,我们设置三个指针lo, mid, high 分别为0,3,7 就可以实现逻辑上的子数组划分）那么需要的额外数组的长度为4 + 4 = 8 .归并的过程可以简要地概括为如下：

1） 将两个子数组中的元素复制到新数组copiedArray 中，以前面提到的例子为例，则copiedArray = [3, 6, 8, 11, 1, 3, 12, 15] ;

2） 设置两个指针分别指向原子数组中对应的第一个元素，假定这两个指针取名为leftIdx 和rightIdx ,则leftIdx = 0 （对应copiedArray 中的第一个元素[3] ），rightIdx = 4 （对应copiedArray 中的第五个元素[1] ）；

3） 比较leftIdx 和rightIdx 指向的数组元素值，选取其中较小的一个并将其值赋给原数组中对应的位置i ,赋值完毕后分别对参与赋值的这两个索引做自增1 操作，如果leftIdx 或rigthIdx 值已经达到对应数组的末尾，则余下只需要将剩下数组的元素按顺序copy 到余下的位置即可。

5. 快速排序

快速排序也是用归并方法实现的一个"分而治之"的排序算法，它的魅力之处在于它能在每次partition （排序算法的核心所在）都能为一个数组元素确定其排序最终正确位置（一次就定位准，下次循环就不考虑这个元素了）。

6. 冒泡排序

冒泡排序可以算是最经典的排序算法了，记得小弟上学时最先接触的也就是这个算法了，因为实现方法最简单，两层for 循环，里层循环中判断相邻两个元素是否逆序，是的话将两个元素交换，外层循环一次，就能将数组中剩下的元素中最小的元素"浮"到最前面，所以称之为冒泡排序。

其实冒泡排序跟选择排序比较相像，比较次数一样，都为n * （n + 1） / 2 ,但是冒泡排序在挑选最小值的过程中会进行额外的交换（冒泡排序在排序中只要发现相邻元素的顺序不对就会进行交换，与之对应的是选择排序，只会在内层循环比较结束之后根据情况决定是否进行交换），所以在我看来，选择排序属于冒泡排序的改进版。