二分查找算法

Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky...

这句话的理解是：思路很简单，细节是魔鬼
下面从一些细节来分析二分查找的几个常用场景：寻找一个数，寻找左侧边界、寻找右侧边界

一、二分查找的框架

def BinarySearch(nums, target):
    left = 0
    right = ...
    while ...:
        mid = int((right + left)/2)
        if nums[mid] == target:
            ...
        elif nums[mid] < target:
            left = ...
        elif nums[mid] > target:
            right = ...
    return ...

分析二分查找的一个细节就是不要出现else，而是把所有的情况用elif写清楚，这样就可以展示所有的细节。上面代码中…就是需要注意的地方。

二、寻找一个数（基本的二分搜索）

场景：在排序数组中搜索一个数，若存在返回索引，否则返回-1

def BinarySearch(nums, target):
    left = 0
    right = len(nums) - 1  ## 注意
    while left <= right:   ## 注意
        mid = int((left + right)/2)
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1  ## 注意
        elif nums[mid] > target:
            right = mid -1  ## 注意
    return -1

Q：为什么while训练的条件是<= 而不是<?
A：因为初始化right的赋值是len(nums)-1，即最后一个元素的索引，而不是len(nums)
这二者可能出现在不同功能的二分查找中，前者的搜索区间是闭区间[left, right]，而后者的搜索区间是左闭右开区间[left, right)，当找到搜索目标时，搜索停止，若没有找到，则返回-1

if nums[mid] == target:
    return mid

那while训练的终止条件是什么呢？应该是搜索区间为空时，训练终止，意味着没有找到目标值。
①while left <= right:的终止条件是left == right + 1,即[right+1, right],可见搜索区间是空的，循环终止，返回-1；

②while left < right: 的终止条件是left == right，即[left, right],搜索空间是非空的，比如[2, 2]，此时训练终止，漏掉了索引2，若返回-1可能会出现错误；
如果一定要用while(left < right),只需要添加一行代码即可

while left < right:
    ...
return left if nums[left] == target else -1

Q、为什么left = mid + 1,right = mid -1，而有的代码是left = mid或right = mid
A:在上面的代码中搜索区间的两端都是闭的[left, right],当索引mid的值不是要找的target时，应该要从[left, mid-1],[mid+1, right]确定下一步的搜索区间，因为中间的mid已经搜索过了。

Q、上述算法有什么缺陷？
A：比如在有序数组nums=[1, 2, 2, 2, 3],target=2中，返回的索引是2，若要返回索引为3，即右侧边界，上述算法是无法解决的，此时需要下面的算法求解。

三、寻找左侧边界的二分搜索

def left_bound(nums, target):
    if len(nums) == 0: return -1
    left = 0
    right = len(nums)
    while left < right:
        mid = int((left + right)/2)
        if nums[mid] == target:
            right = mid
        elif nums[mid] < target:
            left = mid + 1
        elif nums[mid] > target:
            right = mid
    #if nums[mid] == len(nums): return -1
    #return left if nums[left] == target else -1
    return left

Q、为什么while的循环条件是<,而不是<=?
A：用上面同样的分析方法，right的初始值是len(nums)，搜索区间是左闭右开[left, right),while的终止条件是left==right,即搜索区间是[right, right),即为空

Q、为什么没有返回-1的操作，如果nums中不存在这个值怎么办？
A：先看一下左侧边界的含义：

对于这个数组，算法会返回 1。这个 1 的含义可以这样解读：nums 中小于 2 的元素有 1 个。
比如对于有序数组 nums = [2,3,5,7], target = 1，算法会返回 0，含义是：nums 中小于 1 的元素有 0 个。如果 target = 8，算法会返回 4，含义是：nums 中小于 8 的元素有 4 个。
综上可以看出，函数的返回值（即 left 变量的值）取值区间是闭区间 [0, nums.length]，所以我们简单添加两行代码就能在正确的时候 return -1：

while left < right:
    ...
if nums[mid] == len(nums): return -1
return left if nums[left] == target else -1

Q、为什么 left = mid + 1，right = mid ？和之前的算法不一样？
A：这个很好解释，因为我们的「搜索区间」是 [left, right) 左闭右开，所以当 nums[mid] 被检测之后，下一步的搜索区间应该去掉 mid 分割成两个区间，即 [left, mid) 或 [mid + 1, right)。

Q、 为什么该算法能够搜索左侧边界？
A、关键在于对于 nums[mid] == target 这种情况的处理：

if (nums[mid] == target)
        right = mid;

可见，找到 target 时不要立即返回，而是缩小「搜索区间」的上界 right，在区间 [left, mid) 中继续搜索，即不断向左收缩，达到锁定左侧边界的目的。

Q、为什么返回 left 而不是 right？
A、返回left和right都是一样的，因为 while 终止的条件是 left == right。

四、寻找右侧边界的二分搜索

def right_bound(nums, target):
    if len(nums) == 0 : return -1
    left = 0
    right = len(nums)
    while left < right:
        mid = int((left+right)/2)
        if nums[mid] == target:
            left = mid + 1
        elif nums[mid] < target:
            left = mid + 1
        elif nums[mid] > target:
            right = mid
    #if left == 0: return -1
    #return left -1 if nums[left-1] == target else -1
    return right

Q、 为什么这个算法能够找到右侧边界？
A、类似地，关键点还是这里：

if nums[mid] == target:
    left = mid + 1

当 nums[mid] == target 时，不要立即返回，而是增大「搜索区间」的下界 left，使得区间不断向右收缩，达到锁定右侧边界的目的。

Q、为什么最后返回 left - 1 而不像左侧边界的函数，返回 left？这里既然是搜索右侧边界，应该返回 right 才对。
A、首先，while 循环的终止条件是 left == right，所以 left 和 right 是一样的，若要体现右侧的特点，返回 right - 1 好了。
至于为什么要减一，这是搜索右侧边界的一个特殊点，关键在这个条件判断：

if nums[mid] == target:
    left = mid + 1

因为对 left 的更新必须是 left = mid + 1，就是说 while 循环结束时，nums[left] 一定不等于 target 了，而 nums[left - 1]可能是target。
至于为什么 left 的更新必须是 left = mid + 1，同左侧边界搜索，就不再赘述。

Q、为什么没有返回 -1 的操作？如果 nums 中不存在 target 这个值，怎么办？
A、类似之前的左侧边界搜索，因为 while 的终止条件是 left == right，就是说 left 的取值范围是 [0, nums.length]，所以可以添加两行代码，正确地返回 -1：

 if left == 0: return -1
 return left -1 if nums[left-1] == target else -1

五、总结

第一个，最基本的二分查找算法：

因为我们初始化 right = nums.length - 1
所以决定了我们的「搜索区间」是 [left, right]
所以决定了 while (left <= right)
同时也决定了 left = mid+1 和 right = mid-1

因为我们只需找到一个 target 的索引即可
所以当 nums[mid] == target 时可以立即返回

第二个，寻找左侧边界的二分查找：

因为我们初始化 right = nums.length
所以决定了我们的「搜索区间」是 [left, right)
所以决定了 while (left < right)
同时也决定了 left = mid+1 和 right = mid

因为我们需找到 target 的最左侧索引
所以当 nums[mid] == target 时不要立即返回
而要收紧右侧边界以锁定左侧边界

第三个，寻找右侧边界的二分查找：

因为我们初始化 right = nums.length
所以决定了我们的「搜索区间」是 [left, right)
所以决定了 while (left < right)
同时也决定了 left = mid+1 和 right = mid

因为我们需找到 target 的最右侧索引
所以当 nums[mid] == target 时不要立即返回
而要收紧左侧边界以锁定右侧边界

又因为收紧左侧边界时必须 left = mid + 1
所以最后无论返回 left 还是 right，必须减一