一：分治法的思想

 分治法（divide_and_conquer），通俗的來說，要想統治一片領土，可以把這片領土進行分解成若干塊小部分，然後一塊塊地征服，直到所有的小土地都被征服了之後，意味著征服了這一片領土。

分治法的思想分為三部分：
 分（divide）：將問題分解成規模更小的子問題
 治（conquer）：將這些子問題逐個解決，若子問題規模較小而且容易解決則直接解，否則遞迴解決各個子問題
 合（combine）：將已經解決的子問題進行合併，最終得出原問題的解
分治法的使用會伴隨著遞迴的使用，所以對分治法的複雜度分析就是對遞迴的複雜度的分析。

二：分治法的應用
（1）歸併排序：歸併排序是採用分治法的一個非常典型的例子
 分（divide）：將序列一中點為中心一分為二，分為左區間和右
 治（conquer）：把左右兩個子區間分別進行排序
 合（combine）：最後把左區間和右區間合併成有序序列
 T（n）=2T（n/2）+ Θ（n）= Θ（nlgn）
 其中，T（n/2）表示遞迴的複雜度，2表示分為了左右兩個區間，Θ（n）表示合併n個元素的複雜度

import java.util.Arrays;
/*
 * 歸併排序
 */
public class MergeSort {
	
	public static void merge(int []a ,int low,int mid,int high)
	{
		int[] test = Arrays.copyOf(a, high-low+1);
        int i = low;
        int j = mid + 1;
        int k = 0;
        // 把較小的數先移到新陣列中
        while (i <= mid && j <= high) {
            if (a[i] < a[j]) {
            	test[k++] = a[i++];
            } else {
            	test[k++] = a[j++];
            }
        }
        // 把左邊剩餘的數移入陣列
        while (i <= mid) {
        	test[k++] = a[i++];
        }
        // 把右邊邊剩餘的數移入陣列
        while (j <= high) {
        	test[k++] = a[j++];
        }
        // 把新陣列中的數覆蓋nums陣列
        for (int k2 = 0; k2 < test.length; k2++) {
           a[k2 + low] = test[k2];
        }		
	}
	
	public static void mergeSort(int[] a,int low,int high)
	{
		int mid=low+(high-low)/2;
		if(low>=high) return;
		mergeSort(a,low,mid);
		mergeSort(a,mid+1,high);
		//歸併
		merge(a,low,mid,high);
		System.out.println(Arrays.toString(a));
	}
	
	public static void main(String[] args)
	{
		int a[] = {48,51,69,81,23,26,54,85,64,91};
        mergeSort(a,0,a.length-1);
        System.out.println("排序之後" + Arrays.toString(a));    
	}
 

（2）二分查詢：二分查詢又叫折半查詢
 分（divide）：把n個元素分成大致相等的兩部分，取中間的元素與x進行比較
 治（conquer）：在一個子陣列中進行遞迴查詢
 合（combine）：因為實際上並沒有真正的把序列分開，所以最後不用進行合併
 T（n）=T（n/2）+ Θ（1）=T（lgn）

/*
 * 二分查詢
 */
public class BinarySearch {

    private BinarySearch(){}
    
    public static int binarySearch(Comparable[] arr,int low,int high,Comparable target)
    {
    	int mid=(high-low)/2+low;
    	while(low<=high)
    	{    	
	    	if(arr[mid].compareTo(target)==0)
	    	{
	    		return mid;
	    	}
	    	if(target.compareTo(arr[mid])>0)
	    	{
	    		return  binarySearch(arr,mid+1,high,target);
	    	}
	    	else
	    	{
	    		return binarySearch(arr,low,mid-1,target);
	    	}
    	}  	
    	return -1;
    }

    public static void main(String[] args) {

    	Integer srcArray[] = {23, 26, 48, 51, 54, 64, 69, 81, 85, 91};   
        System.out.println(binarySearch(srcArray,0,srcArray.length,81));
    }
}
 

（3）乘方問題：求x的n次方
 T（n）=T（n/2）+ Θ（1）=T（lgn）
 分（divide）：把n進行分解
    當n為奇數時：x^n=x^(n-1)/2  *  x^(n-1)/2  *x
    當n為偶數時：x^n=x^(n/2) * x^(n/2)
 治（conquer）：使用遞迴進行求解x^(n-1)/2或者x^(n/2)
 合（combine）：計算最終結果

public class ChengFangWenTi {
	
	public static long power1(long x,long n)
	{
		if(n==1)
		{
			return x;
		}
		return   x*power(x,n-1);	
		
	}
	
	public static long power(long x,long n)
	{
		if(n==1)
		{
			return x;
		}
		if(n%2==1)				//當n為奇數的時候
		{
			return x*power(x*x,(n-1)/2);
		}
		return   power(x*x,n/2);	//當n為偶數的時候
	}
	
	public static void main(String [] args)
	{
		long x=2,n=10;
		long a=power(x, n);	
		System.out.println(a);
	}
}

（4）斐波那契數列
 分（divide）：把F（n）的問題分成求F（n-1）+F（n-2）的問題
 治（conquer）：使用遞迴求解子問題
 合（combine）：計算最終問題的解

/*
 * 斐波那契數列：又叫兔子數列
 * F(0)=0，F(1)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*）
 */
public class Fibonacci {
	 public static int show(int n){
		 if(n==0)
		 {
		 	return 0;
		 }
	        if(n==1){
	            return 1;
	        }
	        if(n==2){
	            return 1;
	        }
	        return show(n-1)+show(n-2);
	  }
	 
	 public static void main(String[] args)
	 {
		 int n=10;
		 System.out.println(show(n));
	 }
}