归并排序算法

   1import java.util.Arrays;  
   
2.   
   
3/** 
   4.  * java归并算法实现<br> 
   5.  *  
   6.  * 
@author JAVA世纪网(java2000.net, laozizhu.com) 
   7.  
*/  
   
8public 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 = { 1326524713265247132652471,  
  
52.         3 };  
  
53.     // 方法1  
  54.     MergeSort(inputArray, 0, inputArray.length - 1);  
  
55.     System.out.println(Arrays.toString(inputArray));  
  
56.     Integer[] inputArray2 = { 13265247132652471326524,  
  
57.         713 };  
  
58.     // 方法2  
  59.     new MergeSort().sort(inputArray2);  
  
60.     System.out.println(Arrays.toString(inputArray2));  
  
61.   }  
  
62. }  
  
63.   
  
64class 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. } 
posted @ 2009-03-20 16:51  TONYBINLJ  阅读(274)  评论(0编辑  收藏  举报