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)