代码改变世界

归并排序

2014-09-19 19:53  微尘_无名  阅读(160)  评论(0)  编辑  收藏  举报

自顶向下的归并排序采用了分治的思想：将两个已排序的较小的序列“归并”为一个较大的数组。简易实现以用例如下：

 

 1 public class Merge {
 2     
 3     private static Comparable[] aux;
 4     private static void exch(Comparable[] a, int i, int j) {
 5         Comparable tmp = a[i];
 6         a[i] = a[j];
 7         a[j] = tmp;
 8     }
 9 
10     private static boolean less(Comparable a, Comparable b) {
11         return (a.compareTo(b) < 0);
12     }
13 
14     private static void show(Comparable[] a) {
15         int N = a.length;
16         for (int i = 0; i < N; i++) {
17             System.out.print(a[i] + " ");
18         }
19         System.out.println();
20     }
21 
22     public static boolean isSorted(Comparable[] a) {
23         int N = a.length;
24         for (int i = 1; i < N; i++) {
25             if (less(a[i], a[i - 1]))
26                 return false;
27         }
28         return true;
29     }
30 
31     private static void merge(Comparable[] a, int lo, int mid, int hi)
32     {
33         for(int k = lo; k <= hi; k++)
34         {
35             aux[k] = a[k];
36         }
37         int i = lo;
38         int j = mid + 1;
39         for(int k = lo; k <= hi; k++)
40         {
41             if( i > mid) a[k] = aux[j++];
42             else if(j > hi) a[k] = aux[i++];
43             else if(less(aux[j], aux[i])) a[k] = aux[j++];
44             else a[k] = aux[i++];
45         }
46     }
47     
48     private static void sort(Comparable[] a, int lo, int hi)
49     {
50         if(hi <= lo) return;
51         int mid = lo + (hi - lo) / 2;
52         sort(a, lo, mid);
53         sort(a, mid + 1, hi);
54         merge(a, lo, mid, hi);
55     }
56 
57     public static void sort(Comparable[] a)
58     {
59         aux =new Comparable[a.length];
60         sort(a, 0, a.length - 1);
61     }
62     public static void main(String[] args) {
63         String[] a = In.readStrings();
64         sort(a);
65         show(a);
66     }
67 
68 }
View Code

 与此相对应的自底向上的归并排序为：

 

 1 import java.awt.datatransfer.StringSelection;
 2 
 3 
 4 public class MergeBP {
 5 
 6     private static Comparable[] aux;
 7     private static void exch(Comparable[] a, int i, int j) {
 8         Comparable tmp = a[i];
 9         a[i] = a[j];
10         a[j] = tmp;
11     }
12 
13     private static boolean less(Comparable a, Comparable b) {
14         return (a.compareTo(b) < 0);
15     }
16 
17     private static void show(Comparable[] a) {
18         int N = a.length;
19         for (int i = 0; i < N; i++) {
20             System.out.print(a[i] + " ");
21         }
22         System.out.println();
23     }
24 
25     public static boolean isSorted(Comparable[] a) {
26         int N = a.length;
27         for (int i = 1; i < N; i++) {
28             if (less(a[i], a[i - 1]))
29                 return false;
30         }
31         return true;
32     }
33 
34     private static void merge(Comparable[] a, int lo, int mid, int hi)
35     {
36         for(int k = lo; k <= hi; k++)
37         {
38             aux[k] = a[k];
39         }
40         int i = lo;
41         int j = mid + 1;
42         for(int k = lo; k <= hi; k++)
43         {
44             if( i > mid) a[k] = aux[j++];
45             else if(j > hi) a[k] = aux[i++];
46             else if(less(aux[j], aux[i])) a[k] = aux[j++];
47             else a[k] = aux[i++];
48         }
49     }
50     
51     public static void sort(Comparable[] a)
52     {
53         int N = a.length;
54         aux = new Comparable[N];
55         for(int sz = 1; sz < N; sz += sz)
56         {
57             for(int lo = 0; lo < N - sz; lo += sz + sz)
58             {
59                 merge(a, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
60             }
61         }
62     }
63     public static void main(String[] args) {
64         String[] a = In.readStrings();
65         sort(a);
66         show(a);
67     }
68 
69 }
View Code