分治算法的设计思想（二分检索、二分归并排序）

• 分治策略思想：

  • 将原问题划分或者归结为规模较小的子问题。
  • 递归或迭代求解每一个问题。
  • 将子问题的解综合得到原问题的解。

• 性质：

  1. 子问题与原问题具有相同的性质。
  2. 子问题的求解彼此独立。
  3. 划分时子问题的规模尽可能均衡。

• 实现方式： 递归或迭代。

• 二分检索：

算法 Binary Search（T,l,r,x）
输入：数组T，下标从l到r，数x；
输出：j // 若x在T中，j为下标，否则为0。
伪代码：

l <—— 1；r <——n;
while l < = r do 
m <——  ⌊(l + r)/2⌋ // m为T的中间位置，向下取整。
if T[m] = x 
	then return m // x是中位数
else if T[m] > x then r <—— m - 1 // x 小于中间元素，归结成前半个数组。
     else l <—— m + 1
return 0；

• 二分检索时间复杂度分析：
  W(n)= W(⌊n⁄2⌋)+1
  W(n)=1
  W(n)= ⌊log⁡n⌋+1
• Java实现：

public static int BinarySearch(int[] T,int x,int l,int r){

        if(x < T[l] || x > T[r] || l > r){
        return 0;
        }

        int middle = (l + r) / 2;
        if(T[middle] > x){
        return BinarySearch(T, x, l, middle - 1);
        }else if(T[middle] < x){
        //比关键字小则关键字在右区域
        return BinarySearch(T, x, middle + 1, r);
        }else {
        return middle;
        }

}

• 二分归并排序

算法：Merge Sort (A,p,r)
输入：数组A[p...r]
输出：元素按从小到大排序的数组A
if p < r
then q <— ⌊(p + r)/2⌋ // 对半划分，向下取整。
	Merge Sort(A,p,q)  // 子问题1
	Merge Sort(A,q+1,r) // 子问题2
	Merge(A,p,q,r) // 综合解

• Java实现：

class Mergesort {
    private void  mergeSort(int start,int end,int[]arr) {
         if(start>=end){
             return 0;
         }
         int mid=(start+end)/2;
         int left=start;
         int right=mid+1;
         
         //将序列二分成子序列
         mergeSort(start,mid,arr);
         mergeSort(mid+1,end,arr);
         
         //开辟一段数组存储子序列排序后的结果
         int []sort=new int[end-start+1];
         int i=0;
         
         //进行排序，将子序列已排好序的左右两部分序列合并
         while(left<=mid||right<=end){
             if(left>mid){
                 sort[i++]=arr[right++];
             }else if(right>end){
                 sort[i++]=arr[left++];
             }else{
                 if(arr[left]<arr[right]){
                     sort[i++]=arr[left];
                     left++;
                 }else{
                     sort[i++]=arr[right];
                     right++;
                 }
             }
         }
         
         //序列覆盖
        if (sort.length >= 0) System.arraycopy(sort, 0, arr, start, sort.length);
    }
}

• 二分归并排序时间复杂度分析：
  W(n)= 2W(n⁄2)+n-1
  W(1)=0
  W(n)= n log⁡n-n+1