从零开始掌握二分查找：原理、实现与边界分析

二分查找

二分查找（binary search）是一种基于分治策略的高效搜索算法。它利用数据的有序性，每轮缩小一半搜索范围，直至找到目标元素或搜索区间为空为止。

给定一个长度为  的数组 nums ，元素按从小到大的顺序排列且不重复。请查找并返回元素 target 在该数组中的索引。若数组不包含该元素，则返回 $-1$ 。

先初始化指针 $i$ 和 $j$ ，分别指向数组首元素和尾元素，代表搜索区间 $[0, n-1]$  。请注意，中括号表示闭区间，其包含边界值本身。

接下来，循环执行以下两步。

1. 计算中点索引 $m=Math.floor((i+j)/2)$ 。由于 $i$ 和 $j$ 都是 int 类型，因此 $i + j$ 可能会超出 int 类型的取值范围。为了避免大数越界，我们通常采用公式 $m=i + (j-i)/2$ 来计算中点。

2. 判断 nums[m] 和 target 的大小关系，分为以下三种情况。

   1. 当 nums[m] < target 时，说明 target 在区间 $[m+1,j]$ 中，因此执行 $i= m+1$ 。
   2. 当 nums[m] > target 时，说明 target 在区间 $[i, m-1]$ 中，因此执行 $j=m-1$ 。
   3. 当 nums[m] = target 时，说明找到 target ，因此返回索引 $m$ 。

/* 二分查找（双闭区间） */
function binarySearch(nums, target) {
    // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
    let i = 0,
        j = nums.length - 1;
    // 循环，当搜索区间为空时跳出（当 i > j 时为空）
    while (i <= j) {
        // 计算中点索引 m ，使用 parseInt() 向下取整
        const m = parseInt(i + (j - i) / 2);
        if (nums[m] < target)
            // 此情况说明 target 在区间 [m+1, j] 中
            i = m + 1;
        else if (nums[m] > target)
            // 此情况说明 target 在区间 [i, m-1] 中
            j = m - 1;
        else return m; // 找到目标元素，返回其索引
    }
    // 未找到目标元素，返回 -1
    return -1;
}

时间复杂度为 $O(logn)$ ：在二分循环中，区间每轮缩小一半，因此循环次数为 $O(log_2n)$ 。

空间复杂度为 $O(1)$ ：指针 $i$ 和 $j$ 使用常数大小空间。

区间表示方法

常见的区间表示还有“左闭右开”区间，定义为 $[0,n)$, 区间 $[i,j)$ 在 $i=j$ 时为空

优点与局限性

• 二分查找的时间效率高。在大数据量下，对数阶的时间复杂度具有显著优势。
• 二分查找无须额外空间。

二分查找并非适用于所有情况，主要有以下原因。

• 二分查找仅适用于有序数据。
• 二分查找仅适用于数组。
• 小数据量下，线性查找性能更佳。

二分查找插入点

二分查找不仅可用于搜索目标元素，还可用于解决许多变种问题，比如搜索目标元素的插入位置。

无重复元素的情况

给定一个长度为 n 的有序数组 nums 和一个元素 target ，数组不存在重复元素。现将 target 插入数组 nums 中，并保持其有序性。若数组中已存在元素 target ，则插入到其左方。请返回插入后 target 在数组中的索引。

• 当数组中包含 target 时，插入点的索引就是该 target 的索引
• 当数组中不存在 target 时，插入索引为 i

存在重复元素的情况

假设数组中存在多个 target ，则普通二分查找只能返回其中一个 target 的索引，而无法确定该元素的左边和右边还有多少 target。

1. 执行二分查找，得到任意一个 target 的索引，记为  。
2. 从索引  开始，向左进行线性遍历，当找到最左边的 target 时返回。

每轮先计算中点索引  ，再判断 target 和 nums[m] 的大小关系，分为以下几种情况。

• 当 nums[m] < target 或 nums[m] > target 时，说明还没有找到 target ，因此采用普通二分查找的缩小区间操作，从而使指针 i 和 j 向 target 靠近。
• 当 nums[m] == target 时，说明小于 target 的元素在区间 [i,m-1] 中，因此采用 j=m-1 来缩小区间，从而使指针 j 向小于 target 的元素靠近。
• 循环完成后， 指向最左边的 target ， 指向首个小于 target 的元素，因此索引 i 就是插入点。

/* 二分查找插入点（存在重复元素） */
function binarySearchInsertion(nums, target) {
    let i = 0,
        j = nums.length - 1; // 初始化双闭区间 [0, n-1]
    while (i <= j) {
        const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m, 使用 Math.floor() 向下取整
        if (nums[m] < target) {
            i = m + 1; // target 在区间 [m+1, j] 中
        } else if (nums[m] > target) {
            j = m - 1; // target 在区间 [i, m-1] 中
        } else {
            j = m - 1; // 首个小于 target 的元素在区间 [i, m-1] 中
        }
    }
    // 返回插入点 i
    return i;
}