算法——分治

说了递归必然要接着聊一下分治思想

分治不能说是具体一种算法，而是一种思想，可以使用到很多问题当中。

概念

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

（百度百科）

基本思想：将规模较大的问题分割成一些规模较小的相同问题，然后各个击破，分而治之。

当我们求解某些问题时，由于这些问题要处理的数据相当多，或求解过程相当复杂，使得直接求解法在时间上相当长，或者根本无法直接求出。对于这类问题，我们往往先把它分解成几个子问题，找到求出这几个子问题的解法后，再找到合适的方法，把它们组合成求整个问题的解法。如果这些子问题还较大，难以解决，可以再把它们分成几个更小的子问题，以此类推，直至可以直接求出解为止。这就是分治策略的基本思想。（百度百科）

适用条件

1. 可分解为较小规模的相同问题
2. 规模分解至最小有解
3. 分解出的子问题可以合并为大问题的解
4. 各个子问题之间是相互独立的。

基本步骤

1. 分解：将原问题分解为若干规模较小的相同问题。
2. 求解：当问题划分到足够小，可以直接解出。（在求解过程中大都采用了递归的方式）
3. 合并：将各个子问题合并为原问题的解。

复杂性分析

假设原问题的规模为n，将问题分解为m个子问题，则每个问题的规模为n/m。再假设每个规模为1的问题耗费单位时间1，分解以及合并问题所消耗的时间为f(n)，则时间复杂度为：

 

递归复杂度判定定理（Master定理）

这部分有点儿难。。。

后面涉及到再讲（学）好嘛？

写到后面看来不行，，，还是得总结（学习）下。

 

 

例子几个

二分搜索（折半查找）

二分法是最常见的分治算法，将问题一直进行二分解，划分简单、均匀。二分搜索又是二分法中最常见的例子。

问题描述：在已经排好序的n个元素中找到特定元素。

参考：https://baike.baidu.com/item/%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE/10628618?fr=aladdin

代码实现：

public static int binarySearch(Integer[] srcArray, int des) {
    //定义初始最小、最大索引
    int start = 0;
    int end = srcArray.length - 1;
    //确保不会出现重复查找，越界
    while (start <= end) {
        //计算出中间索引值
        int middle = (end + start)>>>1 ;//防止溢出
        if (des == srcArray[middle]) {
            return middle;
        //判断下限
        } else if (des < srcArray[middle]) {
            end = middle - 1;  //容易出错
        //判断上限
        } else {
            start = middle + 1; //容易出错
        }
    }
    //若没有，则返回-1
    return -1;
}

算法分析：每次执行while循环，待搜索的数组大小减半。因此，最坏情况O(logn)。

合并排序

问题描述：合并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

参考：https://baike.baidu.com/item/%E5%90%88%E5%B9%B6%E6%8E%92%E5%BA%8F/2669171?fr=aladdin

代码实现：

public static void mergeSort(int[]array){
   
  int length=array.length;
  int middle=length/2;
 
  if(length>1){
    int[]left=Arrays.copyOfRange(array,0,middle);//拷贝数组array的左半部分
    int[]right=Arrays.copyOfRange(array,middle,length);//拷贝数组array的右半部分
    mergeSort(left);//递归array的左半部分
    mergeSort(right);//递归array的右半部分
    merge(array,left,right);//数组左半部分、右半部分合并到Array
  }
}
 
//合并数组，升序
private static void merge(int[]result,int[]left,int[]right){
 
  int i=0,l=0,r=0;
 
  while(l<left.length&&r<right.length){
    if(left[l]<right[r]){
      result[i]=left[l];
      i++;
      l++;
    }else{
      result[i]=right[r];
      i++;
      r++;
   }
  }
 
  while(r<right.length){//如果右边剩下合并右边的
    result[i]=right[r];
    r++;
    i++;
  }
 
  while(l<left.length){
    result[i]=left[l];
    l++;
    i++;
  }
}

时间复杂度：

当 n>1 时，每次进行合并以及分解的操作需要消耗的时间为O(n)，因此总结出 T(n) = O(nlogn)

快速排序

问题描述：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

参考：https://baike.baidu.com/item/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/369842?fromtitle=%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F&fromid=2084344&fr=aladdin

代码实现：

public static int[] qsort(int arr[],int start,int end) {        
    int pivot = arr[start];        
    int i = start;        
    int j = end;        
    while (i<j) {            
        while ((i<j)&&(arr[j]>pivot)) {                
            j--;            
        }            
        while ((i<j)&&(arr[i]<pivot)) {                
            i++;            
        }            
        if ((arr[i]==arr[j])&&(i<j)) {                
            i++;            
        } else {                
            int temp = arr[i];                
            arr[i] = arr[j];                
            arr[j] = temp;            
        }        
    }        
    if (i-1>start) arr=qsort(arr,start,i-1);        
    if (j+1<end) arr=qsort(arr,j+1,end);        
    return (arr);    
}    

时间复杂度：T(n) = O(nlogn)

线性时间选择

问题描述：给定含有n个元素的序列和一个整数k，要求找出n个元素中的第k小元素。

参考：https://blog.csdn.net/liufeng_king/article/details/8480430

线性时间选择问题有两种解：随机划分线性时间选择 和 利用中位数线性时间选择

利用中位数进行线性时间选择的时间复杂度：O(n)

 

循环赛日程表问题

问题描述：设有n=2^k个运动员，要进行网球循环赛。现在要设计一个满足以下要求的比赛日程表

    （1）每个选手必须与其他n-1个选手各赛一场

    （2）每个选手一天只能赛一次

    （3）循环赛一共进行n-1天

参考：https://blog.csdn.net/wly_2014/article/details/51388263

采用分治策略，可将所有参加比赛的选手分成两部分，n=2^k个选手的比赛日程表就可以通过n=2^（k-1）个选手的的比赛日程表来决定。递归的执行这样的分割，直到只剩下两个选手，比赛日程表的就可以通过这样的分治策略逐步构建。