Shell排序和归并排序

转载http://blog.csdn.net/cjjky/article/details/7029141

希尔排序，也称递减增量排序算法，是插入排序的一种高速而稳定的改进版本。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

• 插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率
• 但插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位

步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列都可以工作。算法最开始以一定的步长进行排序。然后会继续以一定步长进行排序，最终算法以步长为1进行排序。当步长为1时，算法变为插入排序，这就保证了数据一定会被排序。

一直较好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,这样可使Shell排序时间复杂度达到O(N^1.5)。

为了方便扩展，先引入一个抽象的基础类：

[html] view plain copy

1. packagecom.andyidea.algorithms;
3. /**
4. *排序抽象基础类
5. *@authorAndy.Chen
6. *
7. *@param<T>
8. */
9. publicabstractclassSorter<TextendsComparable<T>>{
11. publicabstractvoidsort(T[]array,intfrom,intlen);
13. publicfinalvoidsort(T[]array){
14. sort(array,0,array.length);
15. }
17. protectedfinalvoidswap(T[]array,intfrom,intto){
18. Ttmp=array[from];
19. array[from]=array[to];
20. array[to]=tmp;
21. }
23. }

希尔(Shell)排序算法源码如下：

[html] view plain copy

1. packagecom.andyidea.algorithms;
3. /**
4. *希尔(Shell)排序算法
5. *@authorAdministrator
6. *
7. *@param<T>
8. */
9. publicclassShellSort<TextendsComparable<T>>extendsSorter<T>{
11. @Override
12. publicvoidsort(T[]array,intfrom,intlen){
13. intvalue=1;
14. while((value+1)*2<len){
15. value=(value+1)*2-1;
16. }
18. for(intdelta=value;delta<=1;delta=(delta+1)/2-1){
19. for(inti=0;i<delta;i++){
20. invokeInsertionSort(array,from,len,delta);
21. }
22. }
23. }
25. privatefinalvoidinvokeInsertionSort(T[]array,intfrom,intlen,intdelta){
26. if(len<=1)
27. return;
28. Ttmp=null;
29. for(inti=from+delta;i<from+len;i+=delta)
30. {
31. tmp=array[i];
32. intj=i;
33. for(;j>from;j-=delta)
34. {
35. if(tmp.compareTo(array[j-delta])<0)
36. {
37. array[j]=array[j-delta];
38. }
39. elsebreak;
40. }
41. array[j]=tmp;
42. }
43. }
45. }

归并排序，是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。 也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

算法描述

归并操作的过程如下：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针达到序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

归并排序算法源码如下：

[html] view plain copy

1. packagecom.andyidea.algorithms;
3. importjava.lang.reflect.Array;
5. /**
6. *归并排序法
7. *@authorAndy.Chen
8. *
9. *@param<T>
10. */
11. publicclassMergeSort<TextendsComparable<T>>extendsSorter<T>{
13. @SuppressWarnings("unchecked")
14. @Override
15. publicvoidsort(T[]array,intfrom,intlen){
16. if(len<=1)
17. return;
18. T[]temp=(T[])Array.newInstance(array[0].getClass(),len);
19. mergeSort(array,from,from+len-1,temp);
20. }
22. /**
23. *分成两组排序
24. *@paramarray
25. *@paramfrom
26. *@paramto
27. *@paramtemporary
28. */
29. privatefinalvoidmergeSort(T[]array,intfrom,intto,T[]temporary){
30. if(to<=from)
31. return;
32. intmiddle=(from+to)/2;
33. mergeSort(array,from,middle,temporary);
34. mergeSort(array,middle+1,to,temporary);
35. merge(array,from,to,middle,temporary);
36. }
38. /**
39. *把排序好的序列合并
40. *@paramarray
41. *@paramfrom
42. *@paramto
43. *@parammiddle
44. *@paramtemporary
45. */
46. privatefinalvoidmerge(T[]array,intfrom,intto,intmiddle,T[]temporary){
47. intk=0;
48. intleftIndex=0;
49. intrightIndex=to-from;
50. System.arraycopy(array,from,temporary,0,middle-from+1);
51. for(inti=0;i<to-middle;i++){
52. temporary[to-from-i]=array[middle+i+1];
53. }
55. while(k<to-from+1){
56. if(temporary[leftIndex].compareTo(temporary[rightIndex])<0)
57. {
58. array[k+from]=temporary[leftIndex++];
59. }
60. else
61. {
62. array[k+from]=temporary[rightIndex--];
63. }
64. k++;
65. }
66. }
68. }