Java-分治算法

 1 MERGE(A, p, q, r)
 2    n1 ← q - p + 1
 3    n2 ← r - q
 4    create arrays L[1 ‥ n1 + 1] and R[1 ‥ n2 + 1]
 5    for i ← 1 to n1
 6         do L[i] ← A[p + i - 1]
 7    for j ← 1 to n2
 8         do R[j] ← A[q + j]
 9    L[n1 + 1] ← ∞
10    R[n2 + 1] ← ∞
11   i ← 1
12   j ← 1
13   for k ← p to r
14        do if L[i] ≤ R[j]
15              then A[k] ← L[i]
16                   i ← i + 1
17              else A[k] ← R[j]
18                   j ← j + 1

1 MERGE-SORT(A, p, r)
2  if p < r
3    then q ← ┕(p + r)/2┙
4         MERGE-SORT(A, p, q)
5         MERGE-SORT(A, q + 1, r)
6         MERGE(A, p, q, r)

 1 import java.util.Arrays;
 2 import java.util.Comparator;
 3 
 4 
 5 public class MergeSort {
 6 
 7     /**
 8      * 定义合并方法merge、mergesort方法
 9      * 用泛型方法实现
10      */
11     public static <T> void merge(T[] t, int p, int q, int r, Comparator<? super T> c)
12     {
13         T[] left = Arrays.copyOfRange(t, p, q);
14         T[] right = Arrays.copyOfRange(t, q, r);
15         
16         int indexleft = 0;
17         int indexright = 0;
18         
19         for(int i = p; i < r; i++)
20         {
21             //注意：这里只看算法了，就完全没管终止条件，要不然indexleft的值不断往上走，肯定会越界的，因为整个程序是从p到r的，而且
22             //indexleft和indexright还不一定哪个先结束呢，先结束了的话就没法比较了，就需要针对剩下的做个处理了。。。
23             //表示left到头了
24             if(indexleft >= left.length)
25             {
26                 break;
27             }
28             //表示right到头了
29             if(indexright >= right.length)
30             {
31                 System.arraycopy(left, indexleft, t, i, left.length-indexleft);  
32                 break;
33             }
34             if (c.compare(left[indexleft], right[indexright]) < 0)
35             {
36                 t[i] = left[indexleft];
37                 indexleft++;
38             }
39             else
40             {
41                 t[i] = right[indexright];
42                 indexright++;
43             }
44         }
45     }
46     
47     public static <T> void mergeSort(T[] t, int p, int r, Comparator<? super T> c) 
48     {
49         if(p+1 < r)
50         {
51             int q = (p + r)/2;
52             mergeSort(t, p, q, c);
53             mergeSort(t, q, r, c);
54             merge(t, p, q, r, c);
55         }
56     }
57     
58     public static <T> void mergeSort(T[] t, Comparator<? super T> c)
59     {
60         mergeSort(t, 0, t.length, c);
61     }
62     
63     /**
64      * @param args
65      */
66     public static void main(String[] args) {
67         // TODO Auto-generated method stub
68         Integer[] ints = new Integer[]{2, 0, 5, 23, 1, 4, 8, 56, 19};
69         mergeSort(ints, new Comparator<Integer>(){
70             public int compare(Integer o1, Integer o2){
71                 return o1 - o2;
72             }
73         });
74         
75         for (int i = 0; i < ints.length; i++)
76         {
77             System.out.print(ints[i] + " ");
78         }
79         System.out.println();
80     }
81 
82 }