二分查找及其变体（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))

题目：力扣34

34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

class Solution:
    # https://leetcode.cn/problems/find-first-and-last-position-of-element-in-sorted-array/solutions/1980196/er-fen-cha-zhao-zong-shi-xie-bu-dui-yi-g-t9l9
    # lower_bound 返回最小的满足 nums[i] >= target 的下标 i
    # 如果数组为空，或者所有数都 < target，则返回 len(nums)
    # 要求 nums 是非递减的，即 nums[i] <= nums[i + 1]
    def lower_bound(self, nums, target):
        left = 0
        right = len(nums) - 1  # 闭区间 [left, right]
        while left <= right:  # 区间不为空
            # 循环不变量：
            # nums[left-1] < target
            # nums[right+1] >= target
            mid = (left + right) // 2
            if nums[mid] >= target:
                right = mid - 1  # 范围缩小到 [left, mid-1]
            else:
                left = mid + 1  # 范围缩小到 [mid+1, right]
        # 循环结束后 left = right+1
        # 此时 nums[left-1] < target 而 nums[left] = nums[right+1] >= target
        # 所以 left 就是第一个 >= target 的元素下标
        return left

    def searchRange(self, nums, target):
        start = self.lower_bound(nums, target)
        # 如果出现 start == len(nums)，意味着在整个数组中都没有找到满足 nums[i] >= target 的元素（根据 lower_bound 函数的规则，当所有元素都小于 target 时返回 len(nums)）；或者即使 start 在数组范围内，但 nums[start] 不等于 target，也说明目标值不存在。
        if start == len(nums) or nums[start] != target:
            return [-1, -1]  # nums 中没有 target
        # 如果 start 存在，那么 end 必定存在
        end = self.lower_bound(nums, target + 1) - 1
        return [start, end]

if __name__ == '__main__':
    s = Solution()
    nums = [5,7,7,8,8,10]
    target = 8
    print(s.searchRange(nums, target))

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))