Java实现的几个常用排序算法详细解读.docx
《Java实现的几个常用排序算法详细解读.docx》由会员分享，可在线阅读，更多相关《Java实现的几个常用排序算法详细解读.docx（19页珍藏版）》请在冰点文库上搜索。
Java实现的几个常用排序算法详细解读
Java实现的几个常用排序算法详细解读
2012-06-2715:
33easense2009博客园 字号：
T | T
排序算法很多地方都会用到，近期又重新看了一遍算法，并自己简单地实现了一遍，特此记录下来，为以后复习留点材料。
废话不多说，下面逐一看看经典的排序算法。
AD：
2013云计算架构师峰会课程资料下载
排序算法很多地方都会用到，近期又重新看了一遍算法，并自己简单地实现了一遍，特此记录下来，为以后复习留点材料。
废话不多说，下面逐一看看经典的排序算法：
1.选择排序
选择排序的基本思想是遍历数组的过程中，以i代表当前需要排序的序号，则需要在剩余的[i…n-1]中找出其中的最小值，然后将找到的最小值与i指向的值进行交换。
因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。
举个实例来看看：
1.初始：
[38, 17, 16, 16, 7, 31, 39, 32, 2, 11]
2.
3.i = 0:
[2 , 17, 16, 16, 7, 31, 39, 32, 38 , 11] （0th [38]<->8th [2]）
4.
5.i = 1:
[2, 7 , 16, 16, 17 , 31, 39, 32, 38, 11] （1st [38]<->4th [17]）
6.
7.i = 2:
[2, 7, 11 , 16, 17, 31, 39, 32, 38, 16 ] （2nd [11]<->9th [16]）
8.
9.i = 3:
[2, 7, 11, 16, 17, 31, 39, 32, 38, 16] （ 无需交换 ）
10.
11.i = 4:
[2, 7, 11, 16, 16 , 31, 39, 32, 38, 17 ] （4th [17]<->9th [16]）
12.
13.i = 5:
[2, 7, 11, 16, 16, 17 , 39, 32, 38, 31 ] （5th [31]<->9th [17]）
14.
15.i = 6:
[2, 7, 11, 16, 16, 17, 31 , 32, 38, 39 ] （6th [39]<->9th [31]）
16.
17.i = 7:
[2, 7, 11, 16, 16, 17, 31, 32, 38, 39] （ 无需交换 ）
18.
19.i = 8:
[2, 7, 11, 16, 16, 17, 31, 32, 38, 39] （ 无需交换 ）
20.
21.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）（选择排序只需要一个额外空间用于数组元素交换）。
实现代码：
1./**
2. * Selection Sorting
3. */
4.SELECTION（new Sortable（） {
5. public > void sort（T[] array, boolean ascend） {
6. int len = array.length;
7. for （int i = 0; i < len; i++） {
8. int selected = i;
9. for （int j = i + 1; j < len; j++） {
10. int compare = array[j].compareTo（array[selected]）;
11. if （compare !
= 0 && compare < 0 == ascend） {
12. selected = j;
13. }
14. }
15.
16. exchange（array, i, selected）;
17. }
18. }
19.}）
2.插入排序
插入排序的基本思想是在遍历数组的过程中，假设在序号i之前的元素即[0..i-1]都已经排好序，本趟需要找到i对应的元素x的正确位置k，并且在寻找这个位置k的过程中逐个将比较过的元素往后移一位，为元素x“腾位置”，最后将k对应的元素值赋为x，插入排序也是根据排序的特性来命名的。
以下是一个实例，红色标记的数字为插入的数字，被划掉的数字是未参与此次排序的元素，红色标记的数字与被划掉数字之间的元素为逐个向后移动的元素，比如第二趟参与排序的元素为[11,31,12]，需要插入的元素为12，但是12当前并没有处于正确的位置，于是我们需要依次与前面的元素31、11做比较，一边比较一边移动比较过的元素，直到找到第一个比12小的元素11时停止比较，此时31对应的索引1则是12需要插入的位置。
1.初始：
[11, 31, 12, 5, 34, 30, 26, 38, 36, 18]
2.
3.第一趟：
[11, 31 , 12, 5, 34, 30, 26, 38, 36, 18] （无移动的元素）
4.
5.第二趟：
[11, 12 , 31, 5, 34, 30, 26, 38, 36, 18] （ 31 向后移动）
6.
7.第三趟：
[5 , 11, 12, 31, 34, 30, 26, 38, 36, 18] （ 11, 12, 31 皆向后移动）
8.
9.第四趟：
[5, 11, 12, 31, 34 , 30, 26, 38, 36, 18] （无移动的元素）
10.
11.第五趟：
[5, 11, 12, 30 , 31, 34, 26, 38, 36, 18] （ 31, 34 向后移动）
12.
13.第六趟：
[5, 11, 12, 26 , 30, 31, 34, 38, 36, 18] （ 30, 31, 34 向后移动）
14.
15.第七趟：
[5, 11, 12, 26, 30, 31, 34, 38 , 36, 18] （无移动的元素）
16.
17.第八趟：
[5, 11, 12, 26, 30, 31, 34, 36 , 38, 18] （ 38 向后移动）
18.
19.第九趟：
[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）。
实现代码：
1./**
2. * Insertion Sorting
3. */
4.INSERTION（new Sortable（） {
5. public > void sort（T[] array, boolean ascend） {
6. int len = array.length;
7. for （int i = 1; i < len; i++） {
8. T toInsert = array[i];
9. int j = i;
10. for （; j > 0; j--） {
11. int compare = array[j - 1].compareTo（toInsert）;
12. if （compare == 0 || compare < 0 == ascend） {
13. break;
14. }
15. array[j] = array[j - 1];
16. }
17.
18. array[j] = toInsert;
19. }
20. }
21.}）
3.冒泡排序
冒泡排序可以算是最经典的排序算法了，记得小弟上学时最先接触的也就是这个算法了，因为实现方法最简单，两层for循环，里层循环中判断相邻两个元素是否逆序，是的话将两个元素交换，外层循环一次，就能将数组中剩下的元素中最小的元素“浮”到最前面，所以称之为冒泡排序。
照例举个简单的实例吧：
1.
2.
3.初始状态：
[24, 19, 26, 39, 36, 7, 31, 29, 38, 23]
4.
5.内层第一趟：
[24, 19, 26, 39, 36, 7, 31, 29, 23 , 38 ] （ 9th [23]<->8th [38 ）
6.
7.内层第二趟：
[24, 19, 26, 39, 36, 7, 31, 23 , 29 , 38] （ 8th [23]<->7th [29] ）
8.
9.内层第三趟：
[24, 19, 26, 39, 36, 7, 23 , 31 , 29, 38] （ 7th [23]<->6th [31] ）
10.
11.内层第四趟：
[24, 19, 26, 39, 36, 7, 23, 31, 29, 38] （ 7 、 23 都位于正确的顺序，无需交换）
12.
13.内层第五趟：
[24, 19, 26, 39, 7 , 36 , 23, 31, 29, 38] （ 5th [7]<->4th [36] ）
14.
15.内层第六趟：
[24, 19, 26, 7 , 39 , 36, 23, 31, 29, 38] （ 4th [7]<->3rd [39] ）
16.
17.内层第七趟：
[24, 19, 7 , 26 , 39, 36, 23, 31, 29, 38] （ 3rd [7]<->2nd [26] ）
18.
19.内层第八趟：
[24, 7 , 19 , 26, 39, 36, 23, 31, 29, 38] （ 2nd [7]<->1st [19] ）
20.
21.内层第九趟：
[7 , 24 , 19, 26, 39, 36, 23, 31, 29, 38] （ 1st [7]<->0th [24] ）
22.
23.………
其实冒泡排序跟选择排序比较相像，比较次数一样，都为n*（n+1）/2，但是冒泡排序在挑选最小值的过程中会进行额外的交换（冒泡排序在排序中只要发现相邻元素的顺序不对就会进行交换，与之对应的是选择排序，只会在内层循环比较结束之后根据情况决定是否进行交换），所以在我看来，选择排序属于冒泡排序的改进版。
实现代码：
1./**
2. * Bubble Sorting, it's very similar with Insertion Sorting
3. */
4.BUBBLE（new Sortable（） {
5. public > void sort（T[] array, boolean ascend） {
6. int length = array.length;
7. int lastExchangedIdx = 0;
8. for （int i = 0; i < length; i++） {
9. // mark the flag to identity whether exchange happened to false
10. boolean isExchanged = false;
11. // last compare and exchange happened before reaching index i
12. int currOrderedIdx = lastExchangedIdx > i ?
lastExchangedIdx :
i;
13. for （int j = length - 1; j > currOrderedIdx; j--） {
14. int compare = array[j - 1].compareTo（array[j]）;
15. if （compare !
= 0 && compare > 0 == ascend） {
16. exchange（array, j - 1, j）;
17. isExchanged = true;
18. lastExchangedIdx = j;
19. }
20. }
21. // if no exchange happen means array is already in order
22. if （isExchanged == false） {
23. break;
24. }
25. }
26. }
27.}）
4.希尔排序
希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。
希尔排序的思想是将一个大的数组“分而治之”，划分为若干个小的数组，以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，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题。
具体实例请参照插入排序。
希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大，数据量小的时候建议直接使用插入排序就好了。
实现代码：
1./**
2. * Shell Sorting
3. */
4.SHELL（new Sortable（） {
5. public > void sort（T[] array, boolean ascend） {
6. int length = array.length;
7. int gap = 1;
8.
9. // use the most next to length / 3 as the first gap
10. while （gap < length / 3） {
11. gap = gap * 3 + 1;
12. }
13.
14. while （gap >= 1） {
15. for （int i = gap; i < length; i++） {
16. T next = array[i];
17. int j = i;
18. while （j >= gap） {
19. int compare = array[j - gap].compareTo（next）;
20. // already find its position
21. if （compare == 0 || compare < 0 == ascend） {
22. break;
23. }
24.
25. array[j] = array[j - gap];
26. j -= gap;
27. }
28. if （j !
= i） {
29. array[j] = next;
30. }
31. }
32. gap /= 3;
33. }
34.
35. }
36.}）
5.归并排序
归并排序采用的是递归来实现，属于“分而治之”，将目标数组从中间一分为二，之后分别对这两个数组进行排序，排序完毕之后再将排好序的两个数组“归并”到一起，归并排序最重要的也就是这个“归并”的过程，归并的过程中需要额外的跟需要归并的两个数组长度一致的空间，比如需要规定的数组分别为：
[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到余下的位置即可。
下面给个归并的具体实例：
1.第一趟：
2.
3.辅助数组 [21 , 28, 39 | 35, 38] （数组被拆分为左右两个子数组，以 | 分隔开）
4.
5.[21 , , , , ] （第一次 21 与 35 比较 , 左边子数组胜出， leftIdx = 0 ， i = 0 ）
6.
7.第二趟：
8.
9.辅助数组 [21, 28 , 39 | 35, 38]
10.
11.[21 , 28, , , ] （第二次 28 与 35 比较，左边子数组胜出， leftIdx = 1 ， i = 1 ）
12.
13.第三趟：
[21, 28, 39 | 35 , 38]
14.
15.[21 , 28 , 35, , ] （第三次 39 与 35 比较，右边子数组胜出， rightIdx = 0 ， i = 2 ）
16.
17.第四趟：
[21, 28, 39 | 35, 38 ]
18.
19.[21 , 28 , 35 , 38, ] （第四次 39 与 38 比较，右边子数组胜出， rightIdx = 1 ， i = 3 ）
20.
21.第五趟：
[21, 28, 39 | 35, 38]
22.
23.[21 , 28 , 35 , 38 , 39] （第五次时右边子数组已复制完，无需比较 leftIdx = 2 ， i = 4 ）
以上便是一次归并的过程，我们可以将整个需要排序的数组做有限次拆分（每次一分为二）直到分为长度为1的小数组为止，长度为1时数组已经不用排序了。
在这之后再逆序（由于采用递归）依次对这些数组进行归并操作，直到最后一次归并长度为n/2的子数组，归并完成之后数组排序也完成。
归并排序需要的额外空间是所有排序中最多的，每次归并需要与参与归并的两个数组长度之和相同个元素（为了提供辅助数组）。
则可以推断归并排序的空间复杂度为1+2+4+…+n=n*（
升级会员 