二分查找的注意事项

二分查找算法详解

框架

• 分析二分查找的一个技巧是：不要出现 else，而是把所有情况用 else if 写清楚，这样可以清楚地展现所有细节。

  int binarySearch(int[] nums, int target) {
      int left = 0, right = ...;
  
      while(...) {
          int mid = (right + left) / 2;
          if (nums[mid] == target) {
              ...
          } else if (nums[mid] < target) {
              left = ...
          } else if (nums[mid] > target) {
              right = ...
          }
      }
      return ...;
  }
  

防止溢出的技巧：

• 计算 int mid 变量时，为了防止 lo 和 hi 变量数值太大，导致 (lo + hi) 溢出得到负数，我们巧妙地避免了直接相加，仍然得到了相同的结果，这是二分查找算法的一个细节。

  int binarySearch(int[] nums, int val) {
      int lo = 0, hi = nums.length - 1;
      while (lo <= hi) {
          // int mid = (lo + hi) / 2;
          int mid = lo + (hi - lo) / 2;
          // ...
      }
  }
  

二分查找的应用

寻找一个数

• 搜索一个数，如果存在，返回其索引，否则返回 -1

  int binarySearch(int[] nums, int target) {
      int left = 0; 
      int right = nums.length - 1; // 注意
  
      while(left <= right) { // 注意
          int mid = (right + left) / 2;
          if(nums[mid] == target)
              return mid; 
          else if (nums[mid] < target)
              left = mid + 1; // 注意
          else if (nums[mid] > target)
              right = mid - 1; // 注意
          }
      return -1;
  }
  

• 为什么 while 循环的条件中是 <=，而不是 < ？

  • 因为初始化 right 的赋值是 nums.length - 1，即最后一个元素的索引，而不是 nums.length
  • 区别：前者相当于两端都闭区间 [left, right]，后者相当于左闭右开区间 [left, right)，因为索引大小为 nums.length 是越界的
  • while(left <= right)的终止条件是 left == right + 1，写成区间的形式就是 [right + 1, right]，或者带个具体的数字进去 [3, 2]，可见这时候搜索区间为空，因为没有数字既大于等于 3 又小于等于 2 的吧。所以这时候 while 循环终止是正确的，直接返回 -1 即可。
  • while(left < right)的终止条件是 left == right，写成区间的形式就是 [right, right]，或者带个具体的数字进去 [2, 2]，这时候搜索区间非空，还有一个数 2，但此时 while 循环终止了。也就是说这区间 [2, 2] 被漏掉了，索引 2 没有被搜索，如果这时候直接返回 -1 就可能出现错误。

• 为什么 left = mid + 1，right = mid - 1？

  • 本算法的搜索区间是两端都闭的，即 [left, right]，那么当我们发现索引 mid 不是要找的 target 时，如何确定下一步的搜索区间呢？
  • 当然是去搜索 [left, mid - 1] 或者 [mid + 1, right] ，因为 mid 已经搜索过，应该从搜索区间中去除

• 此算法有什么缺陷？

  • 比如说给你有序数组 nums = [1,2,2,2,3]，target = 2，此算法返回的索引是 2，没错。但是如果我想得到 target 的左侧边界，即索引 1，或者我想得到 target 的右侧边界，即索引 3，这样的话此算法是无法处理的。
  • 这样的需求很常见。你也许会说，找到一个 target 索引，然后向左或向右线性搜索不行吗？可以，但是不好，因为这样难以保证二分查找对数级的复杂度了。

寻找左侧边界

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;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid; // 注意
        }
    }
    return left;
    // 简单添加两行代码就能在正确的时候 return -1
	// if (left == nums.length) return -1; // target 比所有数都大
    // return nums[left] == target ? left : -1;
}

• 为什么 while(left < right) 而不是 <= ?

  • 因为初始化 right = nums.length 而不是 nums.length - 1 ，因此每次循环的搜索区间是 [left, right) 左闭右开
  • while(left < right) 终止的条件是 left == right，此时搜索区间 [left, left) 恰巧为空，所以可以正确终止

• 为什么没有返回 -1 的操作？如果 nums 中不存在 target 这个值，怎么办？

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

• 为什么 left = mid + 1，right = mid ？

  • 因为我们的搜索区间是 [left, right) 左闭右开，所以当 nums[mid] 被检测之后，下一步的搜索区间应该去掉 mid 分割成两个区间，即 [left, mid) 或 [mid + 1, right)

• 为什么该算法能够搜索左侧边界？

  • 关键在于对于 nums[mid] == target 这种情况的处理：

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

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

• 为什么返回 left 而不是 right？

  • 都是一样的，因为 while 终止的条件是 left == right

寻找右侧边界

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; // 注意
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid;
        }
    }
    return left - 1; // 注意
    // 简单添加两行代码就能在正确的时候 return -1
    // if (left == 0) return -1;
	// return nums[left-1] == target ? (left-1) : -1;
}

• 为什么最后返回 left - 1 而不像左侧边界的函数，返回 left？

  • 首先，while 循环的终止条件是 left == right，所以 left 和 right 是一样的，你非要体现右侧的特点，返回 right - 1 好了

  • 至于为什么要减一，这是搜索右侧边界的一个特殊点，关键在这个条件判断：

    if (nums[mid] == target) {
            left = mid + 1;
            // 这样想: mid = left - 1
    

  • 因为我们对 left 的更新必须是 left = mid + 1，就是说 while 循环结束时，nums[left] 一定不等于 target 了，而 nums[left - 1] 可能是 target