全国热线

025-86901720

全国监督投诉热线:9:00-23:00

java开发中比较常用的5个排序算法

今天南京学码思java培训学校​老师就来给大家分享一下java开发中比较常用的5个排序算法及其应用案例,一起来学习一下。

在java开发过程中,排序算法是很常见的一个知识点,很多地方都会用到的,根据项目应用的不同,选择应用的排序算法也不同。今天南京学码思java培训学校老师就来给大家分享一下java开发中比较常用的5个排序算法及其应用案例,一起来学习一下。

java开发中比较常用的5个排序算法

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


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 之前的元素即 [0i-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


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


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


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 * ( n + 2) / 4 (忽略了 n 的奇偶性的判断),时间复杂度比较难估,这里小弟也忘记是多少了(囧)。


实现代码:


1./**


2. * Merge sorting


3. */


4.MERGE(new Sortable() {


5. public


6. this.sort(array, 0, array.length - 1, ascend);


7. }


8.9. private


10. // OPTIMIZE ONE


11. // if the substring's length is less than 20,


12. // use insertion sort to reduce recursive invocation


13. if (hi - lo < 20) {


14. for (int i = lo + 1; i <= hi; i++) {


15. T toInsert = array[i];


16. int j = i;


17. for (; j > lo; j--) {


18. int compare = array[j - 1].compareTo(toInsert);


19. if (compare == 0 || compare < 0 == ascend) {


20. break;


21. }


22. array[j] = array[j - 1];


23. }


24.25. array[j] = toInsert;


26. }


27.28. return;


29. }


30.31. int mid = lo + (hi - lo) / 2;


32. sort(array, lo, mid, ascend);


33. sort(array, mid + 1, hi, ascend);


34. merge(array, lo, mid, hi, ascend);


35. }


36.37. private


38. // OPTIMIZE TWO


39. // if it is already in right order, skip this merge


40. // since there's no need to do so


41. int leftEndCompareToRigthStart = array[mid].compareTo(array[mid + 1]);


42. if (leftEndCompareToRigthStart == 0 || leftEndCompareToRigthStart < 0 == ascend) {


43. return;


44. }


45.46. @SuppressWarnings("unchecked")


47. T[] arrayCopy = (T[]) new Comparable[hi - lo + 1];


48. System.arraycopy(array, lo, arrayCopy, 0, arrayCopy.length);


49.50. int lowIdx = 0;


51. int highIdx = mid - lo + 1;


52.53. for (int i = lo; i <= hi; i++) {


54. if (lowIdx > mid - lo) {


55. // left sub array exhausted


56. array[i] = arrayCopy[highIdx++];


57. } else if (highIdx > hi - lo) {


58. // right sub array exhausted


59. array[i] = arrayCopy[lowIdx++];


60. } else if (arrayCopy[lowIdx].compareTo(arrayCopy[highIdx]) < 0 == ascend) {


61. array[i] = arrayCopy[lowIdx++];


62. } else {


63. array[i] = arrayCopy[highIdx++];


64. }


65. }


66. }


67.})


通过上述理论结合实例的介绍,相信大家对于java中排序算法的应用应该能有进一步了解了。如果还有什么不懂的,可以随时咨询我们在线老师,详细沟通交流。还想获得更多java教程和资料的话,也可以多关注南京学码思网站,我们不定期会为大家更新一些技能干货,对于个人提升技能大有好处。


上一篇:学码思关于javaEE学习的几点建议
下一篇:java线程你了解多少

相关推荐

免费试听 | 学费咨询 | 在线报名 | 申请补贴 | 软件培训 | 网站地图

2016-2020 南京学码思教育科技有限公司 .All Rights Reserved

苏ICP备16033487号 www.njxms.com.cn

全国热线

400-080-3312

全国监督服务热线:9:00-23:00