Java九种排序


    1. 0.排序基类
      /**
       * 为了后面排序算法扩展的方便,引入一个基础类Sorter
       */
      package com.javasort;

      /**
       * 任何排序算法都继承此公共抽象基类Sorter
       * @author Daniel Cheng
       * 
       */
      public abstract class Sorter<E extends Comparable<E>> {

          /**
           * 任何排序算法都重写此抽象方法
           * @param array:欲排序的数组
           * @param from:元素的起始下标
           * @param len:数组的长度
           */
          
          public abstract void sort(E[] array, int from, int len);

          /**
           * 测试排序用例时调用此方法
           * @param array
           */
          public final void sort(E[] array) {
              
              sort(array, 0, array.length);
          }

          /**
           * 需要交换元素顺序时调用此方法
           * @param array
           * @param from
           * @param to
           */
          protected final void swap(E[] array, int from, int to) {
              E tmp = array[from];
              array[from] = array[to];
              array[to] = tmp;
          }
          /**
           * 打印排序后数组元素时调用此方法
           * @param array
           */
          public final void printResult(E[] array){
              for(int i=0;i<array.length;i++){
                  System.out.print(array[i]+",");
              }
          }

      }

      1.冒泡排序
      package com.javasort.bubblesorter;
      /**
       * 冒泡排序:最简单的排序算法了,算法思想是每次从数组末端开始比较相邻两元素,
       * 把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。
       * (当然也可以从数组开始端开始比较相邻两元素,把第i大的冒泡到数组的第N-i个位置。
       * i从0一直到N-1从而完成排序。)
       */
      import com.javasort.Sorter;

      /**
       * @author Daniel Cheng
       * 
       */
      public class BubbleSorter<E extends Comparable<E>> extends Sorter<E> {

          private static  boolean DOWN = true;

          @Override
          public void sort(E[] array, int from, int len) {
              if (DOWN) {
                  bubble_down(array, from, len);
              } else {
                  bubble_up(array, from, len);
              }

          }

          private final void bubble_down(E[] array, int from, int len) {

              for(int i=from;i<from+len;i++){
                  for(int j=from+len-1;j>i;j--){
                      if(array[j].compareTo(array[j-1])<0){
                          swap(array, j-1, j);
                      }
                  }
              }
          }

          private final void bubble_up(E[] array, int from, int len) {
              
              for(int i=from+len-1;i>=from;i--){
                  for(int j=from;j<i;j++){
                      if(array[j].compareTo(array[j+1])>0){
                          swap(array, j, j+1);
                      }
                  }
              }

          }

          static final void up() {
              DOWN=false;
          }
          
      }

      /**
       * 
       */
      package com.javasort.bubblesorter;

      import com.javasort.Sorter;

      /**
       * @author Daniel Cheng
       *
       */
      public class BubbleSorterTest {

          public static void main(String[] args) {
              Comparable[] array={5,1,13,2,17,9,7,4,0};
              Sorter bubbleSorter=new BubbleSorter();
              //BubbleSorter.up();
              bubbleSorter.sort(array);
              bubbleSorter.printResult(array);
          }

      }

      2.插入法排序
      package com.javasort.insertsorter;
      /**
       * 插入法排序在数据规模小的时候十分高效,该算法每次插入第k+1个元素到
       * 前k个有序数组中一个合适的的位置(k=0...N-1),从而完成排序。
       */
      import com.javasort.Sorter;

      /**
       * @author Daniel Cheng
       *
       */
      public class InsertSorter<E extends Comparable<E>> extends Sorter<E> {

          @Override
          public void sort(E[] array, int from, int len) {
              E temp=null;
              for(int i=from+1;i<from+len;i++){
                  temp=array[i];
                  int j=i;
                  for(;j>from;j--){
                      if(temp.compareTo(array[j-1])<0){
                          array[j]=array[j-1];
                      }
                      else
                          break;
                  }
                  array[j]=temp;
                  
              }
              
          }


      }

      package com.javasort.insertsorter;

      import com.javasort.Sorter;

      public class InsertSorterTest {

          public static void main(String[] args) {

              Comparable[] array={5,1,13,2,14,9,7,4,0};
              Sorter insertSort=new InsertSorter();
              
              insertSort.sort(array);
              insertSort.printResult(array);
          }

      }

      3.快速排序
      package com.javasort.quicksorter;

      /**
       * 快速排序是目前使用可能最广泛的排序算法.一般分如下步骤:
       * 1)选择一个枢纽元素(有很对选法,我的实现里采用去中间元素的简单方法)
       * 2)使用该枢纽元素分割数组,使得比该元素小的元素在它的左边,比它大的在右边。并把枢纽元素放在合适的位置。
       * 3)根据枢纽元素最后确定的位置,把数组分成三部分,左边的,右边的,枢纽元素自己,对左边的,右边的分别递归调用快速排序算法即可。
       * 快速排序的核心在于分割算法,也可以说是最有技巧的部分。
       */
      import com.javasort.Sorter;

      /**
       * @author Daniel Cheng
       * 
       */
      public class QuickSorter<E extends Comparable<E>> extends Sorter<E> {

          @Override
          public void sort(E[] array, int from, int len) {
              q_sort(array, from, from + len - 1);
          }

          private final void q_sort(E[] array, int from, int to) {
              if (to - from < 1)
                  return;
              int pivot = selectPivot(array, from, to);

              pivot = partion(array, from, to, pivot);

              q_sort(array, from, pivot - 1);
              q_sort(array, pivot + 1, to);

          }

          private int partion(E[] array, int from, int to, int pivot) {
              E tmp = array[pivot];
              array[pivot] = array[to];// now to's position is available

              while (from != to) {
                  while (from < to && array[from].compareTo(tmp) <= 0)
                      from++;
                  if (from < to) {
                      array[to] = array[from];// now from's position is available
                      to--;
                  }
                  while (from < to && array[to].compareTo(tmp) >= 0)
                      to--;
                  if (from < to) {
                      array[from] = array[to];// now to's position is available now
                      from++;
                  }
              }
              array[from] = tmp;
              return from;

          }

          private int selectPivot(E[] array, int from, int to) {
              return (from + to) / 2;
          }

      }

      /**
       * 
       */
      package com.javasort.quicksorter;

      import com.javasort.Sorter;
      import com.javasort.insertsorter.InsertSorter;

      /**
       * @author Daniel Cheng
       *
       */
      public class QuickSorterTest {

          public static void main(String[] args) {
              Comparable[] array={5,1,13,2,14,9,7,4,0};
              Sorter quickSorter=new QuickSorter();
              
              quickSorter.sort(array);
              quickSorter.printResult(array);
          }

      }

      4.选择排序
      package com.javasort.selectsorter;
      /**
       * 选择排序:相对于冒泡来说,它不是每次发现逆序都交换,而是
       * 在找到全局第i小的时候记下该元素位置,最后跟第i个元素交换,
       * 从而保证数组最终的有序。
       * 相对与插入排序来说,选择排序每次选出的都是全局第i小的,
       * 不会调整前i个元素了。
       */
      import com.javasort.Sorter;
      /**
       * 
       * @author Daniel Cheng
       *
       */

      public class SelectSorter<E extends Comparable<E>> extends Sorter<E> {

          @Override
          public void sort(E[] array, int from, int len) {
              for (int i = 0; i < len; i++) {
                  int smallest = i;
                  int j = i + from;
                  for (; j < from + len; j++) {
                      if (array[j].compareTo(array[smallest]) < 0) {
                          smallest = j;
                      }
                  }
                  swap(array, i, smallest);

              }

          }

      }

      package com.javasort.selectsorter;

      import com.javasort.Sorter;
      import com.javasort.bubblesorter.BubbleSorter;

      public class SelectSorterTest {

          public static void main(String[] args) {
              Comparable[] array={5,1,13,2,17,9,7,4,0};
              Sorter selectSorter=new SelectSorter();
              selectSorter.sort(array);
              selectSorter.printResult(array);
          }

      }

    2. 5.Shell排序   
    3. package com.javasort.shellsorter;   
    4.   
    5. /**  
    6.  * Shell排序可以理解为插入排序的变种,它充分利用了插入排序的两个特点:  
    7.  1)当数据规模小的时候非常高效  
    8.  2)当给定数据已经有序时的时间代价为O(N)  
    9.  所以,Shell排序每次把数据分成若个小块,来使用插入排序,而且之后在这若个小块排好序的情况下把它们合成大一点的小块,继续使用插入排序,不停的合并小块,知道最后成一个块,并使用插入排序。  
    10.  
    11.  这里每次分成若干小块是通过“增量” 来控制的,开始时增量交大,接近N/2,从而使得分割出来接近N/2个小块,逐渐的减小“增量“最终到减小到1。  
    12.  
    13.  一直较好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,这样可使Shell排序时间复杂度达到O(N^1.5)  
    14.  所以我在实现Shell排序的时候采用该增量序列  
    15.  
    16.  */  
    17. import com.javasort.Sorter;   
    18.   
    19. /**  
    20.  *   
    21.  * @author Daniel Cheng  
    22.  *   
    23.  * @param <E>  
    24.  */  
    25. public class ShellSorter<E extends Comparable<E>> extends Sorter<E> {   
    26.   
    27.     @Override  
    28.     public void sort(E[] array, int from, int len) {   
    29.         //1.calculate(计算) first delta value   
    30.         int value=1;   
    31.         while((value+1)*2<len){   
    32.             value=(value+1)*2-1;   
    33.         }   
    34.         //2.小块是通过“增量” 来控制的,开始时增量较大,接近N/2,从而使得分割出来接近N/2个小块,逐渐的减小“增量“最终到减小到1。   
    35.         for(int delta=value;delta>=1;delta=(delta+1)/2-1){   
    36.             for(int i=;i<delta;i++){   
    37.                 modify_insert_sort(array,from+i,len-i,delta);   
    38.             }   
    39.                
    40.         }   
    41.     }   
    42.   
    43.     private final void modify_insert_sort(E[] array, int from, int len, int delta) {   
    44.         if(len<=1)    
    45.             return;   
    46.         E tmp=null;   
    47.         for(int i=from+delta;i<from+len;i+=delta){   
    48.             tmp=array[i];   
    49.             int j=i;   
    50.             for(;j>from;j-=delta){   
    51.                 if(tmp.compareTo(array[j-delta])<){   
    52.                     array[j]=array[j-delta];   
    53.                 }   
    54.                 else break;   
    55.             }   
    56.             array[j]=tmp;   
    57.         }   
    58.            
    59.     }   
    60.   
    61. }   
    62.   
    63. package com.javasort.shellsorter;   
    64.   
    65. import com.javasort.Sorter;   
    66.   
    67. public class ShellSorterTest {   
    68.   
    69.     public static void main(String[] args) {   
    70.         Comparable[] array={5,1,13,2,17,9,7,4,};   
    71.         Sorter shellSorter=new ShellSorter();   
    72.         shellSorter.sort(array);   
    73.         shellSorter.printResult(array);   
    74.     }   
    75.   
    76. }   
    77.   
    78. 6.堆排序   
    79. package com.javasort.heapsorter;   
    80. /**  
    81.  * 堆排序:堆是一种完全二叉树,一般使用数组来实现。  
    82.  * 堆主要有两种核心操作,  
    83.  * 1)从指定节点向上调整(shiftUp)  
    84.  * 2)从指定节点向下调整(shiftDown)  
    85.  * 建堆,以及删除堆定节点使用shiftDwon,而在插入节点时一般结合两种操作一起使用。  
    86.  * 堆排序借助最大值堆来实现,第i次从堆顶移除最大值放到数组的倒数第i个位置,  
    87.  * 然后shiftDown到倒数第i+1个位置,一共执行N次调整,即完成排序。  
    88.  * 显然,堆排序也是一种选择性的排序,每次选择第i大的元素。  
    89.  
    90.  */  
    91. import com.javasort.Sorter;   
    92.   
    93. /**  
    94.  *   
    95.  * @author Daniel Cheng  
    96.  *  
    97.  */  
    98. public class HeapSorter<E extends Comparable<E>> extends Sorter<E> {   
    99.   
    100.     @Override  
    101.     public void sort(E[] array, int from, int len) {   
    102.         build_heap(array,from,len);   
    103.         for(int i=;i<len;i++){   
    104.             //第i次从堆顶移除最大值放到数组的倒数第i个位置,   
    105.             swap(array, from, from+len-1-i);   
    106.             //一直shiftDown(从0开始)到倒数第i+1个位置,一共执行N次调整   
    107.             shift_down(array, from, len-1-i, );   
    108.         }   
    109.     }   
    110.   
    111.     private final void build_heap(E[] array, int from, int len) {   
    112.         //我们从(len- 1)/ 2开始,因为分支节点+1=叶子节点,而所有的叶子节点已经是一个堆   
    113.         int pos=(len-1)/2;   
    114.         for(int i=pos;i>=;i--){   
    115.             shift_down(array,from,len,i);   
    116.         }   
    117.   
    118.     }   
    119.   
    120.     private final void shift_down(E[] array, int from, int len, int pos) {   
    121.         E tmp=array[from+pos];   
    122.         int index=pos*2+1;//用左孩子结点   
    123.         while(index<len)//直到没有孩子结点   
    124.         {   
    125.             if(index+1<len&&array[from+index].compareTo(array[from+index+1])<)//右孩子结点是较大的   
    126.             {   
    127.                 index+=1;//切换到右孩子结点   
    128.             }   
    129.             if(tmp.compareTo(array[from+index])<){   
    130.                 array[from+pos]=array[from+index];   
    131.                 pos=index;   
    132.                 index=pos*2+1;   
    133.                    
    134.             }   
    135.             else{   
    136.                 break;   
    137.             }   
    138.         }   
    139.         array[from+pos]=tmp;   
    140.     }   
    141.   
    142. }   
    143.   
    144. /**  
    145.  *   
    146.  */  
    147. package com.javasort.heapsorter;   
    148.   
    149. import com.javasort.Sorter;   
    150.   
    151. /**  
    152.  * @author Daniel Cheng  
    153.  *  
    154.  */  
    155. public class HeapSorterTest {   
    156.   
    157.     public static void main(String[] args) {   
    158.         Comparable[] array = { 5113217974 };   
    159.         Sorter heapSorter=new HeapSorter();   
    160.         heapSorter.sort(array);   
    161.         heapSorter.printResult(array);   
    162.     }   
    163.   
    164. }   
    165.   
    166. 7.桶式排序   
    167. /**  
    168.  * 桶式排序:  
    169.  * 桶式排序不再是基于比较的了,它和基数排序同属于分配类的排序,  
    170.  * 这类排序的特点是事先要知道待排 序列的一些特征。  
    171.  * 桶式排序事先要知道待排 序列在一个范围内,而且这个范围应该不是很大的。  
    172.  * 比如知道待排序列在[0,M)内,那么可以分配M个桶,第I个桶记录I的出现情况,  
    173.  * 最后根据每个桶收到的位置信息把数据输出成有序的形式。  
    174.  * 这里我们用两个临时性数组,一个用于记录位置信息,一个用于方便输出数据成有序方式,  
    175.  * 另外我们假设数据落在0到MAX,如果所给数据不是从0开始,你可以把每个数减去最小的数。  
    176.  
    177.  *   
    178.  */  
    179. package com.javasort.bucketsorter;   
    180.   
    181. /**  
    182.  * @author Daniel Cheng  
    183.  *  
    184.  */  
    185. public class BucketSorter {   
    186.      public void sort(int[] keys,int from,int len,int max)   
    187.         {   
    188.             int[] temp=new int[len];   
    189.             int[] count=new int[max];   
    190.                
    191.                
    192.             for(int i=;i<len;i++)   
    193.             {   
    194.                 count[keys[from+i]]++;   
    195.             }   
    196.             //calculate position info   
    197.             for(int i=1;i<max;i++)   
    198.             {   
    199.                 count[i]=count[i]+count[i-1];//这意味着有多少数目小于或等于i,因此它也是position+ 1   
    200.             }   
    201.                
    202.             System.arraycopy(keys, from, temp, , len);   
    203.             for(int k=len-1;k>=;k--)//从最末到开头保持稳定性   
    204.             {   
    205.                 keys[--count[temp[k]]]=temp[k];// position +1 =count   
    206.             }   
    207.         }   
    208.         /**  
    209.          * @param args  
    210.          */  
    211.         public static void main(String[] args) {   
    212.   
    213.             int[] a={1,4,8,3,2,9,5,,7,6,9,10,9,13,14,15,11,12,17,16};   
    214.             BucketSorter bucketSorter=new BucketSorter();   
    215.             bucketSorter.sort(a,,a.length,20);//actually is 18, but 20 will also work   
    216.                
    217.                
    218.             for(int i=;i<a.length;i++)   
    219.             {   
    220.                 System.out.print(a[i]+",");   
    221.             }   
    222.   
    223.         }   
    224.   
    225.   
    226. }   
    227.   
    228. 8.基数排序   
    229. /**  
    230.  * 基数排序:基数排序可以说是扩展了的桶式排序,  
    231.  * 比如当待排序列在一个很大的范围内,比如0到999999内,那么用桶式排序是很浪费空间的。  
    232.  * 而基数排序把每个排序码拆成由d个排序码,比如任何一个6位数(不满六位前面补0)拆成6个排序码,  
    233.  * 分别是个位的,十位的,百位的。。。。  
    234.  * 排序时,分6次完成,每次按第i个排序码来排。  
    235.  * 一般有两种方式:  
    236.  * 1) 高位优先(MSD): 从高位到低位依次对序列排序  
    237.  * 2)  低位优先(LSD): 从低位到高位依次对序列排序  
    238.  * 计算机一般采用低位优先法(人类一般使用高位优先),但是采用低位优先时要确保排序算法的稳定性。  
    239.  * 基数排序借助桶式排序,每次按第N位排序时,采用桶式排序。  
    240.  * 对于如何安排每次落入同一个桶中的数据有两种安排方法:  
    241.  * 1)顺序存储:每次使用桶式排序,放入r个桶中,相同时增加计数。  
    242.  * 2)链式存储:每个桶通过一个静态队列来跟踪。  
    243.  
    244.  */  
    245. package com.javasort.radixsorter;   
    246.   
    247. import java.util.Arrays;   
    248.   
    249. /**  
    250.  * @author Daniel Cheng  
    251.  *  
    252.  */  
    253. public class RadixSorter {   
    254. public static boolean USE_LINK=true;   
    255.        
    256.     /**  
    257.      *   
    258.      * @param keys  
    259.      * @param from  
    260.      * @param len  
    261.      * @param radix  key's radix  
    262.      * @param d      how many sub keys should one key divide to  
    263.      */  
    264.     public void sort(int[] keys,int from ,int len,int radix, int d)   
    265.     {   
    266.         if(USE_LINK)   
    267.         {   
    268.             link_radix_sort(keys,from,len,radix,d);   
    269.         }   
    270.         else  
    271.         {   
    272.             array_radix_sort(keys,from,len,radix,d);   
    273.         }   
    274.            
    275.     }   
    276.        
    277.        
    278.     private final void array_radix_sort(int[] keys, int from, int len, int radix,   
    279.             int d)    
    280.     {   
    281.         int[] temporary=new int[len];   
    282.         int[] count=new int[radix];   
    283.         int R=1;   
    284.            
    285.         for(int i=;i<d;i++)   
    286.         {   
    287.             System.arraycopy(keys, from, temporary, , len);   
    288.             Arrays.fill(count, );   
    289.             for(int k=;k<len;k++)   
    290.             {   
    291.                 int subkey=(temporary[k]/R)%radix;   
    292.                 count[subkey]++;   
    293.             }   
    294.             for(int j=1;j<radix;j++)   
    295.             {   
    296.                 count[j]=count[j]+count[j-1];   
    297.             }   
    298.             for(int m=len-1;m>=;m--)   
    299.             {   
    300.                 int subkey=(temporary[m]/R)%radix;   
    301.                 --count[subkey];   
    302.                 keys[from+count[subkey]]=temporary[m];   
    303.             }   
    304.             R*=radix;   
    305.         }   
    306.               
    307.     }   
    308.   
    309.   
    310.     private static class LinkQueue   
    311.     {   
    312.         int head=-1;   
    313.         int tail=-1;   
    314.     }   
    315.     private final void link_radix_sort(int[] keys, int from, int len, int radix, int d) {   
    316.            
    317.         int[] nexts=new int[len];   
    318.            
    319.         LinkQueue[] queues=new LinkQueue[radix];   
    320.         for(int i=;i<radix;i++)   
    321.         {   
    322.             queues[i]=new LinkQueue();   
    323.         }   
    324.         for(int i=;i<len-1;i++)   
    325.         {   
    326.             nexts[i]=i+1;   
    327.         }   
    328.         nexts[len-1]=-1;   
    329.            
    330.         int first=;   
    331.         for(int i=;i<d;i++)   
    332.         {   
    333.             link_radix_sort_distribute(keys,from,len,radix,i,nexts,queues,first);   
    334.             first=link_radix_sort_collect(keys,from,len,radix,i,nexts,queues);   
    335.         }   
    336.         int[] tmps=new int[len];   
    337.         int k=;   
    338.         while(first!=-1)   
    339.         {   
    340.            
    341.             tmps[k++]=keys[from+first];   
    342.             first=nexts[first];   
    343.         }   
    344.         System.arraycopy(tmps, , keys, from, len);   
    345.            
    346.            
    347.     }   
    348.     private final void link_radix_sort_distribute(int[] keys, int from, int len,   
    349.             int radix, int d, int[] nexts, LinkQueue[] queues,int first) {   
    350.            
    351.         for(int i=;i<radix;i++)queues[i].head=queues[i].tail=-1;   
    352.         while(first!=-1)   
    353.         {   
    354.             int val=keys[from+first];   
    355.             for(int j=;j<d;j++)val/=radix;   
    356.             val=val%radix;   
    357.             if(queues[val].head==-1)   
    358.             {   
    359.                 queues[val].head=first;   
    360.             }   
    361.             else    
    362.             {   
    363.                 nexts[queues[val].tail]=first;   
    364.                    
    365.             }   
    366.             queues[val].tail=first;   
    367.             first=nexts[first];   
    368.         }   
    369.            
    370.     }   
    371.     private int link_radix_sort_collect(int[] keys, int from, int len,   
    372.             int radix, int d, int[] nexts, LinkQueue[] queues) {   
    373.         int first=;   
    374.         int last=;   
    375.         int fromQueue=;   
    376.         for(;(fromQueue<radix-1)&&(queues[fromQueue].head==-1);fromQueue++);   
    377.         first=queues[fromQueue].head;   
    378.         last=queues[fromQueue].tail;   
    379.            
    380.         while(fromQueue<radix-1&&queues[fromQueue].head!=-1)   
    381.         {   
    382.             fromQueue+=1;   
    383.             for(;(fromQueue<radix-1)&&(queues[fromQueue].head==-1);fromQueue++);   
    384.                
    385.             nexts[last]=queues[fromQueue].head;   
    386.             last=queues[fromQueue].tail;   
    387.                
    388.         }   
    389.         if(last!=-1)nexts[last]=-1;   
    390.         return first;   
    391.     }   
    392.        
    393.     public static void main(String[] args) {   
    394.         int[] a={1,4,8,3,2,9,5,,7,6,9,10,9,135,14,15,11,33,999999999,222222222,1111111111,12,17,45,16};   
    395.         USE_LINK=true;   
    396.         RadixSorter sorter=new RadixSorter();   
    397.         sorter.sort(a,,a.length,10,10);   
    398.         for(int i=;i<a.length;i++)   
    399.         {   
    400.             System.out.print(a[i]+",");   
    401.         }   
    402.   
    403.   
    404.     }   
    405.   
    406.   
    407. }   
    408.   
    409.   
    410. 9.归并排序   
    411. package com.javasort.mergesorter;   
    412.   
    413. /**  
    414.  * 归并排序:思想是每次把待排的序列分成两部分,分别对这两部分递归地用归并排序,  
    415.  * 完成后把这两个子部分合并成一个序列。归并排序借助一个全局性临时数组来方便  
    416.  * 对子序列的归并,该算法核心在于归并。  
    417.  */  
    418. import java.lang.reflect.Array;   
    419.   
    420. import com.javasort.Sorter;   
    421. /**  
    422.  *   
    423.  * @author Daniel Cheng  
    424.  *  
    425.  * @param <E>  
    426.  */  
    427. public class MergeSorter<E extends Comparable<E>> extends Sorter<E> {   
    428.   
    429.     @SuppressWarnings("unchecked")   
    430.     @Override  
    431.     public void sort(E[] array, int from, int len) {   
    432.         if (len <= 1)   
    433.             return;   
    434.         E[] temporary = (E[]) Array.newInstance(array[].getClass(), len);   
    435.         merge_sort(array, from, from + len - 1, temporary);   
    436.     }   
    437.   
    438.     private final void merge_sort(E[] array, int from, int to, E[] temporary) {   
    439.         if (to <= from) {   
    440.             return;   
    441.         }   
    442.         int middle = (from + to) / 2;   
    443.         merge_sort(array, from, middle, temporary);   
    444.         merge_sort(array, middle + 1, to, temporary);   
    445.         merge(array, from, to, middle, temporary);   
    446.     }   
    447.   
    448.     private final void merge(E[] array, int from, int to, int middle,   
    449.             E[] temporary) {   
    450.         int k = , leftIndex = , rightIndex = to - from;   
    451.         System.arraycopy(array, from, temporary, , middle - from + 1);   
    452.         for (int i = ; i < to - middle; i++) {   
    453.             temporary[to - from - i] = array[middle + i + 1];   
    454.         }   
    455.         while (k < to - from + 1) {   
    456.             if (temporary[leftIndex].compareTo(temporary[rightIndex]) < ) {   
    457.                 array[k + from] = temporary[leftIndex++];   
    458.             } else {   
    459.                 array[k + from] = temporary[rightIndex--];   
    460.             }   
    461.             k++;   
    462.         }   
    463.     }   
    464.   
    465. }   
    466.   
    467.   
    468. /**  
    469.  *   
    470.  */  
    471. package com.javasort.mergesorter;   
    472.   
    473. import com.javasort.Sorter;   
    474.   
    475. /**  
    476.  * @author Daniel Cheng  
    477.  *   
    478.  */  
    479. public class MergeSorterTest {   
    480.     public static void main(String[] args) {   
    481.         Comparable[] array = { 5113217974 };   
    482.         Sorter mergeSorter = new MergeSorter();   
    483.         mergeSorter.sort(array);   
    484.         mergeSorter.printResult(array);   
    485.     }   
    486.   
    487. }  
    488. 转载至:http://www.javaeye.com/topic/512609

你可能感兴趣的:(Java九种排序)