归并排序算法

   1. import java.util.Arrays;  
   2.   
   3. /** 
   4.  * java归并算法实现<br> 
   5.  *  
   6.  * @author JAVA世纪网(java2000.net, laozizhu.com) 
   7.  */  
   8. public class Test {  
   9.   final static int MAXVALUE = 10000;  
  10.   
  11.   static int[] L;  
  12.   
  13.   static int[] R;  
  14.   
  15.   public static void Merge(int[] A, int p, int q, int r) {  
  16.     int n1 = q - p;  
  17.     int n2 = r - q + 1;  
  18.     L = new int[n1 + 1];  
  19.     R = new int[n2 + 1];  
  20.     for (int i = 0; i < n1; i++) {  
  21.       L[i] = A[p + i];  
  22.     }  
  23.     for (int j = 0; j < n2; j++) {  
  24.       R[j] = A[q + j];  
  25.     }  
  26.     L[n1] = MAXVALUE;  
  27.     R[n2] = MAXVALUE;  
  28.     int i = 0, j = 0;  
  29.     for (int k = p; k <= r; k++) {  
  30.       if (L[i] <= R[j]) {  
  31.         A[k] = L[i];  
  32.         i++;  
  33.       } else {  
  34.         A[k] = R[j];  
  35.         j++;  
  36.       }  
  37.     }  
  38.   }  
  39.   
  40.   public static void MergeSort(int[] A, int p, int r) {  
  41.     int q;  
  42.     if (p < r) {  
  43.       q = (p + r) / 2;  
  44.       MergeSort(A, p, q);  
  45.       MergeSort(A, q + 1, r);  
  46.       Merge(A, p, q + 1, r);  
  47.     }  
  48.   }  
  49.   
  50.   public static void main(String[] args) {  
  51.     int[] inputArray = { 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4, 7, 1,  
  52.         3 };  
  53.     // 方法1  
  54.     MergeSort(inputArray, 0, inputArray.length - 1);  
  55.     System.out.println(Arrays.toString(inputArray));  
  56.     Integer[] inputArray2 = { 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4, 7, 1, 3, 2, 6, 5, 2, 4,  
  57.         7, 1, 3 };  
  58.     // 方法2  
  59.     new MergeSort().sort(inputArray2);  
  60.     System.out.println(Arrays.toString(inputArray2));  
  61.   }  
  62. }  
  63.   
  64. class MergeSort {  
  65.   private Comparable[] bridge;  
  66.   
  67.   /** 
  68.    * *利用归并排序算法对数组obj进行排序 
  69.    */  
  70.   public void sort(Comparable[] obj) {  
  71.     if (obj == null) {  
  72.       throw new NullPointerException("The param can not be null!");  
  73.     }  
  74.     bridge = new Comparable[obj.length];// 初始化中间数组  
  75.     mergeSort(obj, 0, obj.length - 1); // 归并排序  
  76.     bridge = null;  
  77.   }  
  78.   
  79.   /** 
  80.    * 将下标从left到right的数组进行归并排序 
  81.    *  
  82.    * @param obj 要排序的数组的句柄 
  83.    * @param left 要排序的数组的第一个元素下标 
  84.    * @param right 要排序的数组的最后一个元素的下标 
  85.    */  
  86.   private void mergeSort(Comparable[] obj, int left, int right) {  
  87.     if (left < right) {  
  88.       int center = (left + right) / 2;  
  89.       mergeSort(obj, left, center);  
  90.       mergeSort(obj, center + 1, right);  
  91.       merge(obj, left, center, right);  
  92.     }  
  93.   }  
  94.   
  95.   /** 
  96.    * *将两个对象数组进行归并，并使归并后为升序。归并前两个数组分别有序 
  97.    *  
  98.    * @param obj 对象数组的句柄 
  99.    * @param left 左数组的第一个元素的下标 
 100.    * @param center 左数组的最后一个元素的下标 
 101.    * @param right 右数组的最后一个元素的下标 
 102.    */  
 103.   private void merge(Comparable[] obj, int left, int center, int right) {  
 104.     int mid = center + 1;  
 105.     int third = left;  
 106.     int tmp = left;  
 107.     while (left <= center && mid <= right) { // 从两个数组中取出小的放入中间数组  
 108.       if (obj[left].compareTo(obj[mid]) <= 0) {  
 109.         bridge[third++] = obj[left++];  
 110.       } else  
 111.         bridge[third++] = obj[mid++];  
 112.     }  
 113.     // 剩余部分依次置入中间数组  
 114.     while (mid <= right) {  
 115.       bridge[third++] = obj[mid++];  
 116.     }  
 117.     while (left <= center) {  
 118.       bridge[third++] = obj[left++];  
 119.     }  
 120.     // 将中间数组的内容拷贝回原数组  
 121.     copy(obj, tmp, right);  
 122.   }  
 123.   
 124.   /** 
 125.    * *将中间数组bridge中的内容拷贝到原数组中 
 126.    *  
 127.    * @param obj 原数组的句柄 
 128.    * @param left 要拷贝的第一个元素的下标 
 129.    * @param right 要拷贝的最后一个元素的下标 
 130.    */  
 131.   private void copy(Comparable[] obj, int left, int right) {  
 132.     while (left <= right) {  
 133.       obj[left] = bridge[left];  
 134.       left++;  
 135.     }  
 136.   }  
 137. }