常用算法-二分法

1.二分法

最简单版本：

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

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

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

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

left_bound( nums, target) {
    left = 0, right = nums.length - 1;
    // 搜索区间为 [left, right]
    while (left <= right) {
        mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            // 搜索区间变为 [mid+1, right]
            left = mid + 1;
        } else if (nums[mid] > target) {
            // 搜索区间变为 [left, mid-1]
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 收缩右侧边界
            right = mid - 1;
        }
    }
    // 检查出界情况
    if (left >= nums.length || nums[left] != target)
        return -1;
    return left;
}

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

int right_bound(int[] nums, int target) {
    int left = 0, right = nums.length - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid - 1;
        } else if (nums[mid] == target) {
            // 收缩左边界
            left = mid + 1;
        }
    }
    // 最后要检查 right 越界的情况
    if (right < 0 || nums[right] != target)
        return -1;
    return right;
}

 

 

def search(nums,target):
    if target in nums:
        left,right=0,len(nums)        #[left ,right)
        if left<right:                #当 left==right时候，循环结束，例如[2，2）是一个空区间满足条件，若换为左闭右闭的区间，left==right不满足条件了，即[2，2] 未能search mid==2的时候
            if nums[mid]==target:
               return mid              # 当mid不满足条件时候，寻找空间为[left,mid) ,[mid+1,right)
            elif nums[mid]>target:
                right=mid               # [left,mid)
            elif nums[mid]<target:
                left=mid+1
    return left if nums[left]==target else -1 #此时 left,right都可，由于条件为left==right时候，循环结束,由于[left ,right)，因此此时需要再判断一次
nums=[1,2,3,4,5,6,7,8,9,10,11,12,14]
print(search(nums,12))

 

i) 求下界，用左闭右开搜索区间[first, last).

  // 在python中正是求下界限，这种写法不会造成溢出

原理：

不管怎么写，只要遵循一个原则，就是L是符合条件的的，R是不符合的（反过来也一样）。这个不变量将贯穿整个二分的过程。

什么意思呢？举个栗子，你需要在[l,r]区间中找到符合条件的最大的x，按照上面的原则，你的初始条件就应该是L=l, R=r+1, 注意这里的R是不符合条件的，因为它超出了边界，所以它不可能是答案。这时候，你的mid如果合法，就说明答案大于等于mid，所以应该更新L，如果mid不合法，直接把R设成mid。至于如何判断合法（是大于等于还是大于），该不该加一减一，按照这个原则都可以很容易想出来。

这样在整个二分的过程中，你会发现，R在任何时候都不可能是答案，那么这个循环的停止条件也很容易判断了，就是L+1=R，这时候说明L已经是符合条件的最大值了，因为再加一就是非法值。

 

 

特点 ： 

1、左闭右开 （所以右边应该 right+1 ，防止取空）

2、left <right  (当等于时， 返回left 或者right 就是目标值）

3、基于左闭右开（右边界，mid = right 可以取到，因此中间值等于目标值时，应该右边界）

                               左边界 ，mid= left+1 ，由于不能重复取left得值

 

 

 

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

int left_bound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0;
    int right = nums.length; // 注意
    
    while (left < right) { // 注意
        int mid = (left + right) / 2;
        if (nums[mid] == target) {              
            right = mid;                          # 找到 target 时不要立即返回，而是缩小「搜索区间」的上界 right，在区间 [left, mid) 中继续搜索，即不断向左收缩，达到锁定左侧边界的目的
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid; // 注意
        }
    }
    if left==len(nums)：  #此时 left==right ,跳出循环 ，可能会出现mid=right的情况（越界）
        return -1 
    return left if nums[left]==target else -1;
}

 

三、寻找右侧边界的二分查找

int right_bound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0, right = nums.length;
    
    while (left < right) {
        int mid = (left + right) / 2;
        if (nums[mid] == target) {
            left = mid + 1; // 注意            #找到target时，不断提升下限（左边界）
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid;
        }
    }
  
    return left - 1; // 注意          #因为我们对 left 的更新必须是 left = mid + 1，就是说 while 循环结束时，nums[left] 一定不等于 target 了，而 nums[left-1] 可能是 target，所以需要left/right -1