二分查找及其变体（Python）

1、Binary Search算法简介

二分查找，它的时间复杂度是 O(logn)。  其核心思想有点类似分治思想。

即每次都通过跟区间中的中间元素对比，将待查找的区间缩小为一半，直到找到要查找的元素，或者区间被缩小为 0。

但是二分查找的代码实现比较容易写错。你需要着重掌握它的三个容易出错的地方：循环退出条件、mid 的取值，low 和 high 的更新。  

二分查找虽然性能比较优秀，但应用场景也比较有限。底层必须依赖数组，并且还要求数据是有序的。对于较小规模的数据查找，我们直接使用顺序遍历就可以了，二分查找的优势并不明显。二分查找更适合处理静态数据，也就是没有频繁的数据插入、删除操作。

2、代码详解

class Solution:
    def bsearch(self, nums, target):
        """Binary search of a target in a sorted array
        without duplicates. If such a target does not exist,
        return -1, othewise, return its index.
        """
        left, right = 0, len(nums)-1
        while left <= right:
            mid = left + (right - left) // 2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                left = mid + 1
            else:
                right = mid - 1

        return -1

s = Solution()
a = [1,3,5,6,7,9,11]
print(s.bsearch(a, 7))

3、二分查找的变体

凡是用二分查找能解决的，绝大部分我们更倾向于用散列表或者二叉查找树。即便是二分查找在内存使用上更节省，但是毕竟内存如此紧缺的情况并不多。

那二分查找真的没什么用处了吗？实际上，求“值等于给定值”的二分查找确实不怎么会被用到，二分查找更适合用在“近似”查找问题，在这类问题上，二分查找的优势更加明显。比如这几种变体问题，用其他数据结构，比如散列表、二叉树，就比较难实现了。

变体的二分查找算法写起来非常烧脑，很容易因为细节处理不好而产生 Bug，容易出错的细节有：终止条件、区间上下界更新方法、返回值选择。

3.1 变体一：查找第一个值等于给定值的元素

3.2 变体二：查找最后一个值等于给定值的元素

from typing import List

def bsearch_left(a: List[int], target: int) -> int:
    """Binary search of the index of the first element
    变体一：查找第一个值等于给定值的元素
    """
    low, high = 0, len(a) - 1
    while low <= high:
        mid = low + (high - low) // 2
        if a[mid] < target:
            low = mid + 1
        elif a[mid] > target:
            high = mid - 1
        else:  # nums[mid]=target
            if mid == 0 or a[mid-1] != target:  # 如果 mid 等于 0，那这个元素已经是数组的第一个元素，那它肯定是要找的；
                # 如果 mid 不等于 0，但 a[mid] 的前一个元素 a[mid-1] 不等于 target，那也说明 a[mid] 就是我们要找的第一个值等于给定值的元素
                return mid
            else:
                high = mid - 1  # 继续找，要找的元素出现在 [low, mid-1] 之间
    return -1


def bsearch_right(a: List[int], target: int) -> int:
    """Binary search of the index of the last element
    变体二：查找最后一个值等于给定值的元素
    """
    low, high = 0, len(a)-1
    while low <= high:
        mid = low + (high - low)//2
        if a[mid] < target:
            low = mid + 1
        elif a[mid] > target:
            high = mid - 1
        else:
            if mid == len(a)-1 or a[mid+1] != target:
                return mid
            else:  # 继续在[mid+1, high]之间找
                low = mid + 1
    return -1
if __name__ == "__main__":
    a = [1, 1, 2, 3, 4, 6, 7, 7, 7, 7, 10, 22]
    print('查找第一个值等于给定值的元素 index')
    print(bsearch_left(a, 1))
    print(bsearch_left(a, 7))

    print('查找最后一个值等于给定值的元素 index')
    print(bsearch_right(a, 1))
    print(bsearch_right(a, 7))

 

3.3 变体三：查找第一个大于等于给定值的元素

3.4 变体四：查找最后一个小于等于给定值的元素

from typing import List

def bsearch_left_not_less(a: List[int], target: int) -> int:
    """Binary search of the index of the first element
    变体三：查找第一个大于等于给定值的元素
    """
    low, high = 0, len(a) - 1
    while low <= high:
        mid = low + (high - low) // 2
        # 满足,继续检查是不是第一个
        if a[mid] >= target:
            if mid == 0 or a[mid-1] < target:  # 是一个
                return mid
            else:  # 不是第一个，则缩小查找区间
                high = mid - 1
        # 不满足
        else:
            low = mid + 1

    return -1

def bsearch_right_not_greater(a: List[int], target: int) -> int:
    """Binary search of the index of the last element
    变体四：查找最后一个小于等于给定值的元素
    """
    low, high = 0, len(a) - 1
    while low <= high:
        mid = low + (high - low) // 2
        if a[mid] <= target:
            if mid == len(a)-1 or a[mid+1] > target:
                return mid
            else:
                low = mid + 1
        else:
            high = mid - 1
    return -1


if __name__ == "__main__":
    a = [1, 1, 2, 3, 4, 6, 7, 7, 7, 7, 10, 22]
    print('找第一个大于等于给定值的元素 index')
    print(bsearch_left_not_less(a, 6))
    print(bsearch_left_not_less(a, 8))

    print('查找最后一个小于等于给定值的元素 index')
    print(bsearch_right_not_greater(a, 6))
    print(bsearch_right_not_greater(a, 8))