常用排序java版.docx

1、常用排序java版这篇排序文章从思想 理解 到实现，然后到整理，花了我几天的时间，现把它记录于此，希望对大家有一定的帮助，写的不好的请不要见笑，写错了的，请指出来我更正。最后如果对你有一定的帮助，请回贴支持一下哦_ ！ 申明： 排序算法思想来自互联网，代码自己实现，仅供参考。 插入排序 直接插入排序、希尔排序 选择排序 简单选择排序、堆排序 交换排序 冒泡排序、快速排序 归并排序 基数排序 排序基类Java代码 1. packagesort; 2. 3. importjava.util.Arrays; 4. importjava.util.Comparator; 5. importjava.u

2、til.Random; 6. 7. /* 8. *排序接口，所有的排序算法都要继承该抽象类，并且要求数组中的 9. *元素要具有比较能力，即数组元素已实现了Comparable接口 10. * 11. *authorjzj 12. *date2009-12-5 13. * 14. *param 15. */16. publicabstractclassSortEextendsComparable 17. 18. publicfinalComparatorDEFAULT_ORDER=newDefaultComparator(); 19. publicfinalComparatorREVERSE_

3、ORDER=newReverseComparator(); 20. 21. /* 22. *排序算法，需实现，对数组中指定的元素进行排序 23. *paramarray待排序数组 24. *paramfrom从哪里 25. *paramend排到哪里 26. *paramc 27. */28. publicabstractvoidsort(Earray,intfrom,intend,Comparatorc); 29. 30. /* 31. *对数组中指定部分进行排序 32. *paramfrom从哪里 33. *paramlen排到哪里 34. *paramarray待排序数组 35. *pa

4、ramc比较器 36. */37. publicvoidsort(intfrom,intlen,Earray,Comparatorc) 38. sort(array,0,array.length-1,c); 39. 40. 41. /* 42. *对整个数组进行排序，可以使用自己的排序比较器，也可使用该类提供的两个比较器 43. *paramarray待排序数组 44. *paramc比较器 45. */46. publicfinalvoidsort(Earray,Comparatorc) 47. sort(0,array.length,array,c); 48. 49. 50. /* 51.

5、 *对整个数组进行排序，采用默认排序比较器 52. *paramarray待排序数组 53. */54. publicfinalvoidsort(Earray) 55. sort(0,array.length,array,this.DEFAULT_ORDER); 56. 57. 58. /默认比较器（一般为升序，但是否真真是升序还得看E是怎样实现Comparable接口的） 59. privateclassDefaultComparatorimplementsComparator 60. publicintcompare(Eo1,Eo2) 61. returnpareTo(o2); 62. 6

6、3. 64. 65. /反序比较器，排序刚好与默认比较器相反 66. privateclassReverseComparatorimplementsComparator 67. publicintcompare(Eo1,Eo2) 68. returnpareTo(o1); 69. 70. 71. 72. /* 73. *交换数组中的两个元素的位置 74. *paramarray待交换的数组 75. *parami第一个元素 76. *paramj第二个元素 77. */78. protectedfinalvoidswap(Earray,inti,intj) 79. if(i!=j)/只有不是同

7、一位置时才需交换 80. Etmp=arrayi; 81. arrayi=arrayj; 82. arrayj=tmp; 83. 84. 85. 86. /* 87. *数组元素后移 88. *paramarray待移动的数组 89. *paramstartIndex从哪个开始移 90. *paramendIndex到哪个元素止 91. */92. protectedfinalvoidmove(Earray,intstartIndex,intendIndex) 93. for(inti=endIndex;i=startIndex;i-) 94. arrayi+1=arrayi; 95. 96.

8、 97. 98. /* 99. *以指定的步长将数组元素后移，步长指定每个元素间的间隔 100. *paramarray待排序数组 101. *paramstartIndex从哪里开始移 102. *paramendIndex到哪个元素止 103. *paramstep步长 104. */105. protectedfinalvoidmove(Earray,intstartIndex,intendIndex,intstep) 106. for(inti=endIndex;i=startIndex;i-=step) 107. arrayi+step=arrayi; 108. 109. 110.

9、111. /测试方法 112. SuppressWarnings(unchecked) 113. publicstaticfinalEextendsComparablevoidtestSort(Sortsorter,Earray) 114. 115. if(array=null) 116. array=randomArray(); 117. 118. /为了第二次排序，需拷贝一份 119. EtmpArr=(E)newComparablearray.length; 120. System.arraycopy(array,0,tmpArr,0,array.length); 121. 122. S

10、ystem.out.println(源-+Arrays.toString(tmpArr); 123. 124. sorter.sort(array,sorter.REVERSE_ORDER); 125. System.out.println(降-+Arrays.toString(array); 126. 127. sorter.sort(tmpArr,sorter.DEFAULT_ORDER); 128. System.out.println(升-+Arrays.toString(tmpArr); 129. 130. 131. /生成随机数组 132. SuppressWarnings(unc

11、hecked) 133. privatestaticEextendsComparableErandomArray() 134. Randomr=newRandom(System.currentTimeMillis(); 135. Integera=newIntegerr.nextInt(30); 136. for(inti=0;ia.length;i+) 137. ai=newInteger(r.nextInt(100); 138. 139. return(E)a; 140. 141. package sort;import java.util.Arrays;import java.util.

12、Comparator;import java.util.Random;/* * 排序接口，所有的排序算法都要继承该抽象类，并且要求数组中的 * 元素要具有比较能力，即数组元素已实现了Comparable接口 * * author jzj * date 2009-12-5 * * param */public abstract class SortE extends Comparable public final Comparator DEFAULT_ORDER = new DefaultComparator(); public final Comparator REVERSE_ORDER =

13、new ReverseComparator(); /* * 排序算法，需实现，对数组中指定的元素进行排序 * param array 待排序数组 * param from 从哪里 * param end 排到哪里 * param c */ public abstract void sort(E array, int from, int end, Comparator c); /* * 对数组中指定部分进行排序 * param from 从哪里 * param len 排到哪里 * param array 待排序数组 * param c 比较器 */ public void sort(int f

14、rom, int len, E array, Comparator c) sort(array, 0, array.length - 1, c); /* * 对整个数组进行排序，可以使用自己的排序比较器，也可使用该类提供的两个比较器 * param array 待排序数组 * param c 比较器 */ public final void sort(E array, Comparator c) sort(0, array.length, array, c); /* * 对整个数组进行排序，采用默认排序比较器 * param array 待排序数组 */ public final void s

15、ort(E array) sort(0, array.length, array, this.DEFAULT_ORDER); /默认比较器（一般为升序，但是否真真是升序还得看E是怎样实现Comparable接口的） private class DefaultComparator implements Comparator public int compare(E o1, E o2) return pareTo(o2); /反序比较器，排序刚好与默认比较器相反 private class ReverseComparator implements Comparator public int com

16、pare(E o1, E o2) return pareTo(o1); /* * 交换数组中的两个元素的位置 * param array 待交换的数组 * param i 第一个元素 * param j 第二个元素 */ protected final void swap(E array, int i, int j) if (i != j) /只有不是同一位置时才需交换 E tmp = arrayi; arrayi = arrayj; arrayj = tmp; /* * 数组元素后移 * param array 待移动的数组 * param startIndex 从哪个开始移 * param

17、 endIndex 到哪个元素止 */ protected final void move(E array, int startIndex, int endIndex) for (int i = endIndex; i = startIndex; i-) arrayi + 1 = arrayi; /* * 以指定的步长将数组元素后移，步长指定每个元素间的间隔 * param array 待排序数组 * param startIndex 从哪里开始移 * param endIndex 到哪个元素止 * param step 步长 */ protected final void move(E ar

18、ray, int startIndex, int endIndex, int step) for (int i = endIndex; i = startIndex; i -= step) arrayi + step = arrayi; /测试方法 SuppressWarnings(unchecked) public static final E extends Comparable void testSort(Sort sorter, E array) if (array = null) array = randomArray(); /为了第二次排序，需拷贝一份 E tmpArr = (E)

19、 new Comparablearray.length; System.arraycopy(array, 0, tmpArr, 0, array.length); System.out.println(源 - + Arrays.toString(tmpArr); sorter.sort(array, sorter.REVERSE_ORDER); System.out.println(降 - + Arrays.toString(array); sorter.sort(tmpArr, sorter.DEFAULT_ORDER); System.out.println(升 - + Arrays.to

20、String(tmpArr); /生成随机数组 SuppressWarnings(unchecked) private static E extends Comparable E randomArray() Random r = new Random(System.currentTimeMillis(); Integer a = new Integerr.nextInt(30); for (int i = 0; i a.length; i+) ai = new Integer(r.nextInt(100); return (E) a; 插入排序直接插入排序 一般直接插入排序的时间复杂度为O (

21、 n2 ) ，但是当数列基本有序时，如果按照有数列顺序排时，时间复杂度将改善到O( n )，另外，因直接插入排序算法简单，如果待排序列规模不很大时效率也较高。在已经排好序的序列中查找待插入的元素的插入位置，并将待插入元素插入到有序列表中的过程。将数组分成两部分，初始化时，前部分数组为只有第一个元素，用来存储已排序元素，我们这里叫 arr1 ；后部分数组的元素为除第一个元素的所有元素，为待排序或待插入元素，我们这里叫 arr2 。排序时使用二层循环：第一层对 arr2 进行循环，每次取后部分数组（待排序数组）里的第一个元素（我们称为待排序元素或称待插入元素） e1 ，然后在第二层循环中对 arr

22、1 （已排好序的数组）从第一个元素往后进行循环，查到第一个大于待插入元素（如果是升序排列）或第一个小于待插入元素（如果是降序排列） e2 ，然后对 arr1 从 e2 元素开始往后的所有元素向后移，最后把 e1 插入到原来 e2 所在的位置。这样反复地对 arr2 进行循环，直到 arr2 中所有的待插入的元素都插入到 arr1 中。 Java代码 1. packagesort; 2. 3. importjava.util.Comparator; 4. 5. /* 6. *直接插入排序算法 7. *authorjzj 8. *date2009-12-5 9. * 10. *param 11.

23、*/12. publicclassInsertSortEextendsComparableextendsSort 13. 14. /* 15. *排序算法的实现，对数组中指定的元素进行排序 16. *paramarray待排序的数组 17. *paramfrom从哪里开始排序 18. *paramend排到哪里 19. *paramc比较器 20. */21. publicvoidsort(Earray,intfrom,intend,Comparatorc) 22. 23. /* 24. *第一层循环：对待插入（排序）的元素进行循环 25. *从待排序数组断的第二个元素开始循环，到最后一个元素（包括）止 26. */27. for(inti=from+1;i=end;i+) 28. /* 29. *第二层循环：对有序数组进行循环，且从有序数组最第一个元素开始向后循环 30. *找到第一个大于待插入的元素 31. *有序数组初始元素只有一个，且为源数组的第一个元素，一个元素数组总是有序的 32. */33. for(intj=0;j0) 37. /找到插入点后，从插入点开始向后