二分查找算法详解

时间：2021-07-21 17:43:53 收藏：0 阅读：0

一、binarySearch框架

数组必须升序排列;
不要出现 else，而是把所有情况用 else if 写清楚，这样可以清楚地展现所有细节;

计算 mid 时需要技巧防止溢出： let mid = left + Math.floor((right - left) / 2);

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

二、Note: 搜索一个数，如果存在，返回其索引，否则返回 -1.

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

因为初始化 right 的赋值是 nums.length - 1，即最后一个元素的索引，而不是 nums.length;

while 循环当找到目标值就停止搜索，返回索引；但是当 while 循环结束都没有找到的时候，就返回-1，那什么时候 while 循环终止呢？

[left, right] 终止条件是 left == right + 1，即 [right + 1, right] ，带个具体的数字进去 [3, 2]，可见这时候搜索区间为空，因为没有数字既大于等于 3 又小于等于 2 的吧。所以这时候 while 循环终止是正确的，直接返回 -1 即可;

[left, right）终止条件是 left == right，即 [left, right],带个具体的数字进去 [2, 2]，这时候搜索区间非空，还有一个数 2，但此时 while 循环终止了。也就是说这区间 [2, 2] 被漏掉了，索引 2 没有被搜索，如果这时候直接返回 -1 就可能出现错误，所以打个补丁：最后一行 return 语句变为 return nums[left] === target ? left : -1，且 right 的变化应该为 right = mid ，因为我们的「搜索区间」是 [left, right) 左闭右开，所以当 nums[mid] 被检测之后，下一步的搜索区间应该去掉 mid 分割成两个区间，即 [left, mid) 或 [mid + 1, right)

为什么 left = mid + 1，right = mid - 1？我看有的代码是 right = mid 或者 left = mid，没有这些加加减减，到底怎么回事，怎么判断？

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

此算法有什么缺陷？

比如说给你有序数组 nums = [1,2,2,2,3]，target = 2，此算法返回的索引是 2，没错。但是如果我想得到 target 的左侧边界，即索引 1，或者我想得到 target 的右侧边界，
即索引 3，这样的话此算法是无法处理的。

```sh

function binarySearch(nums, target) {
  let left = 0;
  let right = nums.length - 1;
  while (left <= right) {
    let mid = left + Math.floor((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;
}
console.log(binarySearch([1, 2, 3, 4, 5, 6, 7], 3));//2

```

三、 Note: 搜索一个数，如果存在，返回其第一次出现时的索引，否则返回 -1.

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

```sh

function binarySearchLeft(nums, target) {
  if (nums.length == 0) return -1;
  let left = 0;
  let right = nums.length;
  while (left < right) {
    let mid = left + Math.floor((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.length) return -1;
  return nums[left] === target ? left : -1;
}
console.log(binarySearchLeft([1, 2, 2, 2, 3], 2));//1

```

四、 Note: 搜索一个数，如果存在，返回其最后一次出现时的索引，否则返回 -1.

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

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

```sh

function binarySearchRight(nums, target) {
  if (nums.length == 0) return -1;
  let left = 0;
  let right = nums.length;
  while (left < right) {
    let mid = left + Math.floor((right - left) / 2);
    if (nums[mid] === target) {
      left = mid + 1;
    } else if (nums[mid] < target) {
      left = mid + 1;
    } else if (nums[mid] > target) {
      right = mid;
    }
  }
  if (left === 0) return -1;
  return nums[left - 1] === target ? left - 1 : -1;
}
console.log(binarySearchRight([1, 2, 2, 2, 3], 2)); //3

```

五、总结

一个基本的二分查找

因为我们初始化 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，必须减一

六、给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。

方法一：使用上面写好的api

var searchRange1 = function (nums, target) {
  // let left = nums.indexOf(target);
  // let right = nums.lastIndexOf(target);
  // return [left, right];
  let left = binarySearchLeft(nums, target);
  let right = binarySearchRight(nums, target);
  return [left, right];
};

方法二、封装一个统一的api

var binarySearch = function (nums, target, flag) {
  if (nums.length == 0) return -1;
  let left = 0;
  let right = nums.length;
  while (left < right) {
    let mid = left + Math.floor((right - left) / 2);
    if (nums[mid] === target) {
      flag ? (right = mid) : (left = mid + 1);
    } else if (nums[mid] < target) {
      left = mid + 1;
    } else if (nums[mid] > target) {
      right = mid;
    }
  }
  if (flag && left === nums.length) return -1;
  if (!flag && left === 0) return -1;
  return flag
    ? nums[left] === target
      ? left
      : -1
    : nums[left - 1] === target
    ? left - 1
    : -1;
};
var searchRange2 = function (nums, target) {
  let len = nums.length;
  if (len === 0) {
    return [-1, -1];
  }
  let left = binarySearch(nums, target, true);
  if (left === -1) {
    return [-1, -1];
  }
  let right = binarySearch(nums, target, false);
  return [left, right];
};
// console.log(searchRange2([5, 7, 7, 8, 8, 10], 8)); //[3,4]