二分查找的左闭右开和左闭右闭写法中各种小细节深究

写在前面

lower_bound查找的是升序序列中的第一个出现target的pos，区间应从右向左收缩。
upper_bound查找的是升序序列中的最后一个出现target的pos，区间应从左向右收缩。

主循环判断本质目的是为了确保整个区间能够被检索到。

1. 左闭右开

• 每次循环的区间都是[left, right)，在二分的时候，搜索区间去掉mid使得原始区间分为两块[left, mid), [mid+1, right)，这样才能保证整个区间都被检索。
  所以left = mid + 1和right = mid

• 主循环判断条件：left < right，这和我们在其他循环中是一样的。
  比如for (int i = 0; i < nums.size(); ++i)
  左闭右开的写法更常见，c++中迭代器返回的end就是右开的。
  在主循环跳出的时候，其实是[left, left)，这个搜索空间为空，主循环确保了整个区间的检索。

lower_bound

• 实现lower_bound关键是target == nums[mid]的时候，我们仍然让right = mid，实现从右向左收缩.

    int lower_bound(vector<int>& nums, int target){
        int left = 0, right = nums.size(), mid;
        while (left < right){
            mid = left + (right - left)/2;
            if (nums[mid] == target){
                right = mid;
            }else if (nums[mid] < target){
                left = mid + 1;
            }else if (nums[mid] > target){
                right = mid;
            }
        }
        // 边界
        if (left >= nums.size() || nums[left] != target) return -1;
        return left;
    }

注意

• 如果A = [2,3,4,5], target = 1, 最后返回的left = 0；
• 如果A = [2,3,4,5], target = 9, 最终返回的left = 4；
• 所以返回的left的区间是[0, A.size()]，表示小于target数字的个数
• 若想要实现没有找到的时候返回-1，我们应该再加这样一行代码：
  if(left == A.size() || A[left] != target) {return -1;}

upper_bound

• 实现upper_bound关键是target == nums[mid]的时候，left = mid + 1实现从左向右搜索。
• 最终推出循环返回的left是最后出现target的下一位，需要left-1来正确返回下标

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

2. 左闭右闭

• 主循环判断条件：left <= right，这和我们在其他循环中是一样的。
  比如for (int i = 0; i <= nums.size()-1; ++i)

lower_bound

int left_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) {
            // 别返回，锁定左侧边界
            right = mid - 1;
        }
    }
    // 最后要检查 left 越界的情况
    if (left >= nums.length || nums[left] != target)
        return -1;
    return left;
}

• 最终返回的的left = right + 1，left有大于nums.length的情况：

      // 检查出界情况
      if (left >= nums.length || nums[left] != target)
          return -1;
      return left;
  

upper_bound

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;
}

当 target 比所有元素都小时，right 会被减到 -1，所以需要在最后防止越界.