二分搜索及其问题拓展

二分搜索是适用于有序数组的高效搜索方式，本文先介绍二分搜索的递归和非递归形式，然后将其拓展到类似问题。

1. 二分搜索的基本实现

1.1 递归实现

def binarySearch(array, num):
    """
    采用递归的算法: 这种递归不构造新的数组，只对指针进行递归
    :param array:
    :param num:
    :return:
    """
    if not array:
        return False
    low, high = 0, len(array)-1
    return __binarySearch(array, num, low, high)


def __binarySearch(array, num, low, high):
    if low > high:
        return False

    mid = low + (high - low) // 2
    if array[mid] == num:
        return True

    elif array[mid] > num:
        return __binarySearch(array, num, low, mid-1)

    else:
        return __binarySearch(array, num, mid + 1, high)

1.2 非递归实现

def binarySearch(array, num):
    """
    采用双指针的方式
    :param array:
    :param num:
    :return:
    """
    low, high = 0, len(array) - 1
    while low <= high:
        mid = low + (high-low)//2    # 防止溢出
        # mid = (low + high)//2
        if array[mid] == num:
            return True
        elif array[mid] < num:
            low = mid + 1
        else:
            high = mid - 1
    return False

无论是采用递归还是非递归的形式，二分法的关键注意点包括：
（1）确定问题缩小的方向和具体边界。即根据mid值，将问题规模往左半区间还是右半区间缩小；边界是开区间还是闭区间；
（2）求mid值时应注意防止数值溢出，在偶数情况下mid值可能与原low值相重复。

2. 二分搜索的问题拓展

二分法的应用场合很多，在采用二分法前需要确定问题确实可以通过这种方式进行缩减和区间确定。除了之前介绍的旋转数组的搜索问题，这里再简单介绍下二分法的其他拓展，并同时给出递归和非递归的求解。

2.1 边界范围问题

【问题】求非下降数组的上界和下界，如[1,3,5,7,8,8,8,8,9,10]中8的下界索引为4，上界索引为7，若无返回-1。、
【思路】通过二分法缩小问题规模，当mid值等于目标值，如果mid位为数组首位或者mid-1处的值小于则可确定此时mid值为下界，否则根据mid值与目标值的大小关系进行问题二分。上界搜索的原理与之类似。

• 递归方法

def lowerBoundary(array, num, lo, hi):
    """
    用递归的方式求解下界
    :param array: 数组
    :param num: target值
    :param lo: left指针
    :param hi: right指针
    :return:
    """
    if lo > hi:
        return -1

    mid = lo + (hi - lo)//2
    if array[mid] == num and (mid==0 or array[mid-1] < num):
        return mid

    elif array[mid] >= num:
        return lowerBoundary(array, num, lo, mid - 1)

    else:
        return lowerBoundary(array, num, mid + 1, hi)

def upperBoundary(array, num, lo, hi):
    """
    递归方式求解upperboundary
    :param array:
    :param num:
    :param lo: left指针
    :param hi: right指针
    :return:
    """
    if lo > hi:
        return -1

    mid = lo + (hi - lo)//2
    if array[mid] == num and (mid == len(array)-1 or array[mid+1] > num):
        return mid

    elif array[mid] <= num:
        return upperBoundary(array, num, mid+1, hi)

    else:
        return upperBoundary(array, num, lo, mid-1)

• 非递归方法

def lowerBoundary(array, num):
    """
    用二分遍历的方式进行搜索上界
    :param array:
    :param num:
    :return:
    """
    lo, hi = 0, len(array)-1
    while lo <= hi:
        mid = lo + (hi - lo)//2
        if array[mid] == num and (mid==0 or array[mid-1]<num):
            return mid
        elif array[mid] >= num:
            hi = mid - 1
        else:
            lo = mid + 1
    return -1

def upperBoundary(array, num):
    """
    二分搜索的方式进行遍历
    :param array:
    :param num:
    :return:
    """
    lo, hi = 0, len(array) - 1
    while lo <= hi:
        mid = lo + (hi - lo)//2
        if array[mid] == num and (mid == len(array)-1 or array[mid+1]> num):
            return mid
        elif array[mid] <= num:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

2.2 模糊边界问题

【问题】求数组中最接近于target值的小于值或大于值。如[1,3,5,7,8,8,8,8,9,10]中8的最接近的小于值为7， 最接近的大于值为9，若没有返回-1
【思路】同样求得mid值，若mid值小于目标值且mid位处于数组末尾或者mid+1值大于等于目标值时，可确定为最接近的小于值。否则，需要 根据mid位值与目标值的大小关系进行二分搜索。对于最接近的大于值的求解，思路与之类似。

• 递归方法

def nearestSmallerValue(array, num, lo, hi):
    """
    递归方式
    :param array:
    :param num:
    :param lo:
    :param hi:
    :return:
    """

    if lo > hi:
        return -1

    mid = lo + (hi - lo)//2

    if array[mid] < num and (mid == len(array)-1 or array[mid+1] >= num):
        return array[mid]

    elif array[mid] < num:
        return nearestSmallerValue(array, num, mid+1, hi)

    else:
        return nearestSmallerValue(array, num, lo, mid-1)

def nearestBiggerValue(array, num, lo, hi):
    """
    递归方式搜索最接近目标的大值
    :param array:
    :param num:
    :param lo:
    :param hi:
    :return:
    """
    if lo > hi:
        return -1

    mid = lo + (hi - lo)//2
    if array[mid] > num and (mid==0 or array[mid-1] <= num):
        return array[mid]

    elif array[mid] > num:
        return nearestBiggerValue(array, num, lo, mid-1)

    else:
        return nearestBiggerValue(array, num, mid+1, hi)

• 非递归方式

def nearestSamllerValue(array, num):
    """
    二分遍历方式
    :param array:
    :param num:
    :return:
    """
    lo, hi = 0, len(array)-1
    while lo <= hi:
        mid = lo + (hi - lo)//2
        if array[mid] < num and (mid==len(array)-1 or array[mid+1] >= num):
            return array[mid]
        elif array[mid] < num:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1

def nearestBiggerValue(array, num):
    """
    采用二分搜索的遍历方法进行寻值
    :param array:
    :param num:
    :return:
    """
    lo, hi = 0, len(array)-1
    while lo <= hi:
        mid = lo + (hi - lo)//2
        if array[mid] > num and (mid==0 or array[mid-1] <= num):
            return array[mid]
        elif array[mid] > num:
            hi = mid - 1
        else:
            lo = mid + 1
    return -1

由上面两个例子不难看出，利用二分搜索进行解题的关键在于确定问题分解方向和边界情况。