Java-分治算法

一、分治算法的原理

分治算法就是将一个规模为N的问题分解成K个规模较小的子问题，这些子问题相互独立且与原问题性质相同，求出子问题的解，就可以得出原问题的解

二、分治算法的伪代码实现

合并算法Merge

 MERGE(A, p, q, r)
    n1 ← q - p + 1
    n2 ← r - q
    create arrays L[1 ‥ n1 + 1] and R[1 ‥ n2 + 1]
    for i ← 1 to n1
         do L[i] ← A[p + i - 1]
    for j ← 1 to n2
         do R[j] ← A[q + j]
    L[n1 + 1] ← ∞
    R[n2 + 1] ← ∞
   i ← 1
   j ← 1
   for k ← p to r
        do if L[i] ≤ R[j]
              then A[k] ← L[i]
                   i ← i + 1
              else A[k] ← R[j]
                   j ← j + 1

分治算法：包括“分治”和“合并”

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

三、分治算法的Java代码实现

 import java.util.Arrays;
 import java.util.Comparator;

 public class MergeSort {

     /**
      * 定义合并方法merge、mergesort方法
      * 用泛型方法实现
      */
     public static <T> void merge(T[] t, int p, int q, int r, Comparator<? super T> c)
     {
         T[] left = Arrays.copyOfRange(t, p, q);
         T[] right = Arrays.copyOfRange(t, q, r);

         int indexleft = 0;
         int indexright = 0;

         for(int i = p; i < r; i++)
         {
             //注意：这里只看算法了，就完全没管终止条件，要不然indexleft的值不断往上走，肯定会越界的，因为整个程序是从p到r的，而且
             //indexleft和indexright还不一定哪个先结束呢，先结束了的话就没法比较了，就需要针对剩下的做个处理了。。。
             //表示left到头了
             if(indexleft >= left.length)
             {
                 break;
             }
             //表示right到头了
             if(indexright >= right.length)
             {
                 System.arraycopy(left, indexleft, t, i, left.length-indexleft);
                 break;
             }
             if (c.compare(left[indexleft], right[indexright]) < 0)
             {
                 t[i] = left[indexleft];
                 indexleft++;
             }
             else
             {
                 t[i] = right[indexright];
                 indexright++;
             }
         }
     }

     public static <T> void mergeSort(T[] t, int p, int r, Comparator<? super T> c)
     {
         if(p+1 < r)
         {
             int q = (p + r)/2;
             mergeSort(t, p, q, c);
             mergeSort(t, q, r, c);
             merge(t, p, q, r, c);
         }
     }

     public static <T> void mergeSort(T[] t, Comparator<? super T> c)
     {
         mergeSort(t, 0, t.length, c);
     }

     /**
      * @param args
      */
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         Integer[] ints = new Integer[]{2, 0, 5, 23, 1, 4, 8, 56, 19};
         mergeSort(ints, new Comparator<Integer>(){
             public int compare(Integer o1, Integer o2){
                 return o1 - o2;
             }
         });

         for (int i = 0; i < ints.length; i++)
         {
             System.out.print(ints[i] + " ");
         }
         System.out.println();
     }

 }

四、复杂度分析

合并部分的时间复杂度为O(N)