归并排序算法思想:

分而治之(divide – conquer);每个递归过程涉及三个步骤

第一, 分解: 把待排序的 n 个元素的序列分解成两个子序列, 每个子序列包括 n/2 个元素.

第二, 治理: 对每个子序列分别调用归并排序MergeSort, 进行递归操作

第三, 合并: 合并两个排好序的子序列,生成排序结果.

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. }  

import java.util.Arrays;

/**
 * java归并算法实现<br>
 * 
 * @author JAVA世纪网(java2000.net, laozizhu.com)
 */
public class Test {
  final static int MAXVALUE = 10000;

  static int[] L;

  static int[] R;

  public static void Merge(int[] A, int p, int q, int r) {
    int n1 = q - p;
    int n2 = r - q + 1;
    L = new int[n1 + 1];
    R = new int[n2 + 1];
    for (int i = 0; i < n1; i++) {
      L[i] = A[p + i];
    }
    for (int j = 0; j < n2; j++) {
      R[j] = A[q + j];
    }
    L[n1] = MAXVALUE;
    R[n2] = MAXVALUE;
    int i = 0, j = 0;
    for (int k = p; k <= r; k++) {
      if (L[i] <= R[j]) {
        A[k] = L[i];
        i++;
      } else {
        A[k] = R[j];
        j++;
      }
    }
  }

  public static void MergeSort(int[] A, int p, int r) {
    int q;
    if (p < r) {
      q = (p + r) / 2;
      MergeSort(A, p, q);
      MergeSort(A, q + 1, r);
      Merge(A, p, q + 1, r);
    }
  }

  public static void main(String[] args) {
    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,
        3 };
    // 方法1
    MergeSort(inputArray, 0, inputArray.length - 1);
    System.out.println(Arrays.toString(inputArray));
    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,
        7, 1, 3 };
    // 方法2
    new MergeSort().sort(inputArray2);
    System.out.println(Arrays.toString(inputArray2));
  }
}

class MergeSort {
  private Comparable[] bridge;

  /**
   * *利用归并排序算法对数组obj进行排序
   */
  public void sort(Comparable[] obj) {
    if (obj == null) {
      throw new NullPointerException("The param can not be null!");
    }
    bridge = new Comparable[obj.length];// 初始化中间数组
    mergeSort(obj, 0, obj.length - 1); // 归并排序
    bridge = null;
  }

  /**
   * 将下标从left到right的数组进行归并排序
   * 
   * @param obj 要排序的数组的句柄
   * @param left 要排序的数组的第一个元素下标
   * @param right 要排序的数组的最后一个元素的下标
   */
  private void mergeSort(Comparable[] obj, int left, int right) {
    if (left < right) {
      int center = (left + right) / 2;
      mergeSort(obj, left, center);
      mergeSort(obj, center + 1, right);
      merge(obj, left, center, right);
    }
  }

  /**
   * *将两个对象数组进行归并，并使归并后为升序。归并前两个数组分别有序
   * 
   * @param obj 对象数组的句柄
   * @param left 左数组的第一个元素的下标
   * @param center 左数组的最后一个元素的下标
   * @param right 右数组的最后一个元素的下标
   */
  private void merge(Comparable[] obj, int left, int center, int right) {
    int mid = center + 1;
    int third = left;
    int tmp = left;
    while (left <= center && mid <= right) { // 从两个数组中取出小的放入中间数组
      if (obj[left].compareTo(obj[mid]) <= 0) {
        bridge[third++] = obj[left++];
      } else
        bridge[third++] = obj[mid++];
    }
    // 剩余部分依次置入中间数组
    while (mid <= right) {
      bridge[third++] = obj[mid++];
    }
    while (left <= center) {
      bridge[third++] = obj[left++];
    }
    // 将中间数组的内容拷贝回原数组
    copy(obj, tmp, right);
  }

  /**
   * *将中间数组bridge中的内容拷贝到原数组中
   * 
   * @param obj 原数组的句柄
   * @param left 要拷贝的第一个元素的下标
   * @param right 要拷贝的最后一个元素的下标
   */
  private void copy(Comparable[] obj, int left, int right) {
    while (left <= right) {
      obj[left] = bridge[left];
      left++;
    }
  }
}

运行结果

[1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7]

[1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7]