分治法——二分查找

分治法——二分查找

问题：给定已按升序排好序的n个元素a[0:n-1]，现要在这n个元素中找出一特定元素x，返回其（首次）出现的位置。

虽说是老问题，但是并不可简单忽视，网上有人说“十个二分九个错”，还是要好好梳理一下。

参考自：https://www.zhihu.com/question/36132386?sort=created

思路分析

问题一，区间开闭

设查找区间左右端点为left与right，这两个点其实开闭均可，一般统一用闭合。

问题二，中位数

中位数有上位中位数和下位中位数之分，如序列1234上位中位数为2，下位中位数为1，此处的2和1均为下标。设序列长度为length，则有：

下位中位数lowerMedian = (length-1)/2

上位中位数upperMedian = length/2

最常采用的是下位中位数。

在闭区间的前提下，中位数可以写成：

Median = left + (right - left)/2

问题三，溢出

不要将中位数写成：

Median = (left + right)/2

这样写有溢出的风险。

问题四，终结条件

不要用left==right作为终结条件，会被跳过。例如在序列[1,5]中寻找0，若终结条件为left==right，就会导致循环一直出不去。

正确的终结条件是：

left > right

满足终结条件后，直接返回-1即可。

问题五，递推方向

若没有重复元素，那么根据Median所对应的值大于、小于或者等于target，可以分别进行左移right，右移left和返回Median操作。值得注意的是例如在左移right时，可以不仅仅将其设为Median，而是设为Median-1，可以减少一些计算。

若有重复元素，返回所查找的元素第一次出现的位置，那么我们可以从前面的没有重复元素的思路考虑。考察left指针，只有在Median对应的值小于target时，left才会右移，而Median对应的值又大于等于left对应的值，那么当target等于left对应的值时，left将不再右移。换言之left最终将停留在target第一次出现的位置，这正是我们想要的。对于right而言，同理将会停留在target最后一次出现的位置，最终返回的就是left和right的中位数。为了使其最终返回第一次出现的位置，那么在Median对应的值等于target的时候，继续向左搜索，即可最终到达left。

问题六，查找元素不存在

假如查找的元素不存在，算法将会返回其按升序排序应该插入的位置。如果想返回-1，需要在查找过程中记录是否找到了查找的元素，以便进行区分。

代码——递归与非递归写法

//二分查找指定元素target在序列a[0..n-1]中所在的位置
//无重复元素，递归实现
//输入：一个排序完成的序列a[0..n-1]以及其中的一个元素target
//输出：target在序列中所在的下标
int bs(int* a,int target,int N,int left,int right){
    int mid = left + (right - left)/2;
    if(left > right) return -1;
    if(target > a[mid]) return bs(a,target,N,mid+1,right);
    if(target < a[mid]) return bs(a,target,N,left,mid-1);
    if(target == a[mid]) return mid;
}

//二分查找指定元素target在序列a[0..n-1]中所在的位置
//无重复元素，非递归实现
//输入：一个排序完成的序列a[0..n-1]以及其中的一个元素target
//输出：target在序列中所在的下标
int bs(int *a,int target,int N){
    int left = 0,right = N-1;
    while(left <= right){
        int mid = left + (right - left)/2;
        if(a[mid] < target) left = mid+1;
        if(a[mid] > target) right = mid-1;
        if(a[mid] == target) return mid;
    }
    return -1;
}

//二分查找指定元素target在序列a[0..n-1]中所在的位置
//重复元素，递归实现，不考虑查找元素不存在的情况
//输入：一个排序完成的序列a[0..n-1]以及其中的一个元素target
//输出：target在序列中所在的下标
int bs(int* a,int target,int N,int left,int right){
    int mid = left + (right - left)/2;
    if(left > right) return mid;
    if(target > a[mid]) return bs(a,target,N,mid+1,right);
    if(target < a[mid]) return bs(a,target,N,left,mid-1);
    if(target == a[mid]) return bs(a,target,N,left,mid-1);
    return 0;
}

//二分查找指定元素target在序列a[0..n-1]中所在的位置
//重复元素，非递归实现，查找失败返回-1
//输入：一个排序完成的序列a[0..n-1]以及其中的一个元素target
//输出：target在序列中所在的下标
int bs(int* a,int target,int N){
    int left = 0,right = N-1;
    bool flg = false;
    while(left <= right){
        int mid = left + (right - left)/2;
        if(a[mid] < target) left = mid + 1;
        if(a[mid] > target) right = mid - 1;
        if(a[mid] == target) {flg = true;right = mid - 1;}
    }
    if(flg) return left;
    else return -1;
}

复杂度分析

问题输入规模：序列长度n

基本操作：比较a[mid]和target

是否仅与问题输入规模有关：否，需要考虑最好、最坏、平均

是否递归：二者复杂度一样，分析递归

根据递归时间复杂度计算公式，a=1，b=2，f(n) = O(1)，代入得最坏时间复杂度为：O(logn)，最好时间复杂度为O(1)