Skip to content

二分查找

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

1. 查找需求

给定一个长度为n的数组nums,元素按从小到大的顺序排列且不重复。请查找并返回元素target在该数组中的索引。若数组不包含该元素,则返回-1。示例如图所示。 Alt text 如图所示,我们先初始化指针i=0和j=n-1,分别指向数组首元素和尾元素,代表搜索区间[0, n-1]。请注意,中括号表示闭区间,其包含边界值本身。接下来,循环执行以下两步:

  1. 计算中点索引m=⌊(i+j)/2⌋, 其中⌊ ⌋表示向下取整操作。
  2. 判断nums[m]和target的大小关系,分为以下三种情况:
    • 当nums[m]<target时,说明target在区间[m+1,j]中,因此执行i=m+1。
    • 当nums[m]>target时,说明target在区间[i, m-1]中,因此执行j=m-1。
    • 当nums[m]=target时,说明找到target,因此返回索引m。
      最后若数组不包含目标元素,搜索区间最终会缩小为空。此时返回-1。 Alt text 值得注意的是,由于i和j都是int类型,因此i+j可能会超出int类型的取值范围。为了避免大数越界,我们通常采用公式m=⌊i+(j-i)/2⌋来计算中点。
java
/* 二分查找(双闭区间) */
int binarySearch(int[] nums, int target) {
    // 初始化双闭区间[0, n-1] ,即i, j分别指向数组首元素、尾元素
    int i = 0, j = nums.length - 1;
    // 循环,当搜索区间为空时跳出(当i>j时为空)
    while (i <= j) {
        int m = i + (j - i) / 2; // 计算中点索引m
        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):在二分循环中,区间每轮缩小一半,因此循环次数为log₂n。
空间复杂度为O(1):指针i和j使用常数大小空间。

3. 区间表示方法

除了上述双闭区间外,常见的区间表示还有"左闭右开"区间,定义为[0, n),即左边界包含自身,右边界不包含自身。在该表示下,区间[i, j)在i=j时为空。我们可以基于该表示实现具有相同功能的二分查找算法:

java
/* 二分查找(左闭右开区间) */
int binarySearchLCRO(int[] nums, int target) {
    // 初始化左闭右开区间 [0, n) ,即 i, j 分别指向数组首元素、尾元素+1
    int i = 0, j = nums.length;
    // 循环,当搜索区间为空时跳出(当 i = j 时为空)
    while (i < j) {
        int m = i + (j - i) / 2; // 计算中点索引 m
        if (nums[m] < target) // 此情况说明 target 在区间 [m+1, j) 中
            i = m + 1;
        else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
            j = m;
        else // 找到目标元素,返回其索引
            return m;
    }
    // 未找到目标元素,返回 -1
    return -1;
}

如图所示,在两种区间表示下,二分查找算法的初始化、循环条件和缩小区间操作皆有所不同。由于"双闭区间"表示中的左右边界都被定义为闭区间,因此通过指针i和指针j缩小区间的操作也是对称的。这样更不容易出错,因此一般建议采用"双闭区间"的写法Alt text

5. 优点与局限性

二分查找在时间和空间方面都有较好的性能。二分查找的时间效率高。在大数据量下,对数阶的时间复杂度具有显著优势。例如,当数据大小n=2²⁰时,线性查找需要2²⁰=1048476轮循环,而二分查找仅需log₂2²⁰=20轮循环。
二分查找无须额外空间。相较于需要借助额外空间的搜索算法(例如哈希查找),二分查找更加节省空间。
然而,二分查找并非适用于所有情况,主要有以下原因:

  • 二分查找仅适用于有序数据。若输入数据无序,为了使用二分查找而专门进行排序,得不偿失。因为排序算法的时间复杂度通常为O(nlogn),比线性查找和二分查找都更高。对于频繁插入元素的场景,为保持数组有序性,需要将元素插入到特定位置,时间复杂度为O(n),也是非常昂贵的。
  • 二分查找仅适用于数组。二分查找需要跳跃式(非连续地)访问元素,而在链表中执行跳跃式访问的效率较低,因此不适合应用在链表或基于链表实现的数据结构。
  • 小数据量下,线性查找性能更佳。在线性查找中,每轮只需1次判断操作;而在二分查找中,需要1次加法、1次除法、1~3次判断操作、1次加法(减法),共4~6个单元操作;因此,当数据量n较小时,线性查找反而比二分查找更快。

6. 二分查找插入点

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

6.1 搜索需求

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

6.2 无重复元素的情况

如果想复用上一节的二分查找代码,则需要回答以下两个问题:

  • 问题一:当数组中包含target时,插入点的索引是否是该元素的索引?
    题目要求将target插入到相等元素的左边,这意味着新插入的target替换了原来target的位置。也就是说,当数组包含target时,插入点的索引就是该 target的索引。
  • 问题二:当数组中不存在target时,插入点是哪个元素的索引?
    二分结束时一定有i指向首个大于target的元素,j指向首个小于target的元素。易得当数组不包含target时,插入索引为i。代码如下所示:
java
/* 二分查找插入点(无重复元素) */
int binarySearchInsertionSimple(int[] nums, int target) {
    int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
    while (i <= j) {
        int m = i + (j - i) / 2; // 计算中点索引 m
        if (nums[m] < target) {
            i = m + 1; // target 在区间 [m+1, j] 中
        } else if (nums[m] > target) {
            j = m - 1; // target 在区间 [i, m-1] 中
        } else {
            return m; // 找到 target ,返回插入点 m
        }
    }
    // 未找到 target ,返回插入点 i
    return i;
}

6.3 存在重复元素的情况

假设数组中存在多个target,则普通二分查找只能返回其中一个target的索引,而无法确定该元素的左边和右边还有多少target。题目要求将目标元素插入到最左边,所以我们需要查找数组中最左一个target的索引。初步考虑通过下图所示的步骤实现:

  • 执行二分查找,得到任意一个target的索引,记为k
  • 从索引k开始,向左进行线性遍历,当找到最左边的target时返回。
    Alt text 此方法虽然可用,但其包含线性查找,因此时间复杂度为O(n)。当数组中存在很多重复的target时,该方法效率很低。现考虑拓展二分查找代码。如图所示,整体流程保持不变,每轮先计算中点索引m,再判断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的元素靠近。

循环完成后,i指向最左边的target,j指向首个小于target的元素,因此索引i就是插入点。
Alt text 观察以下代码,判断分支 nums[m] > target 和 nums[m] == target 的操作相同,因此两者可以合并。即便如此,我们仍然可以将判断条件保持展开,因为其逻辑更加清晰、可读性更好。

java
/* 二分查找插入点(存在重复元素) */
int binarySearchInsertion(int[] nums, int target) {
    int i = 0, j = nums.length - 1; // 初始化双闭区间 [0, n-1]
    while (i <= j) {
        int m = i + (j - i) / 2; // 计算中点索引 m
        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;
}

总结

总的来看,二分查找无非就是给指针i和j分别设定搜索目标,目标可能是一个具体的元素(例如target),也可能是一个元素范围(例如小于target的元素)。在不断的循环二分中,指针i和j都逐渐逼近预先设定的目标。最终,它们或是成功找到答案,或是越过边界后停止。

7. 二分查找边界

7.1 查找需求

给定一个长度为n的有序数组nums ,其中可能包含重复元素。请返回数组中最左一个元素target的索引。若数组中不包含该元素,则返回-1。

7.2 查找左边界

回忆二分查找插入点的方法,搜索完成后i指向最左一个target,因此查找插入点本质上是在查找最左一个target的索引。考虑通过查找插入点的函数实现查找左边界。请注意,数组中可能不包含target,这种情况可能导致以下两种结果:

  • 插入点的索引i越界。
  • 元素nums[i]与target不相等。
    当遇到以上两种情况时,直接返回-1即可。代码如下所示:
java
/* 二分查找最左一个 target */
int binarySearchLeftEdge(int[] nums, int target) {
    // 等价于查找 target 的插入点
    int i = binary_search_insertion.binarySearchInsertion(nums, target);
    // 未找到 target ,返回 -1
    if (i == nums.length || nums[i] != target) {
        return -1;
    }
    // 找到 target ,返回索引 i
    return i;
}

7.3 查找右边界

那么如何查找最右一个target呢?最直接的方式是修改代码,替换在nums[m] == target情况下的指针收缩操作。代码在此省略,有兴趣的读者可以自行实现。 下面我们介绍两种更加取巧的方法。

  1. 复用查找左边界
    实际上,我们可以利用查找最左元素的函数来查找最右元素,具体方法为:将查找最右一个target转化为查找最左一个target + 1。如图所示,查找完成后,指针i指向最左一个target + 1(如果存在),而j指向最右一个target ,因此返回j即可。
    Alt text 请注意,返回的插入点是i,因此需要将其减1,从而获得j:
java
/* 二分查找最右一个 target */
int binarySearchRightEdge(int[] nums, int target) {
    // 转化为查找最左一个 target + 1
    int i = binary_search_insertion.binarySearchInsertion(nums, target + 1);
    // j 指向最右一个 target ,i 指向首个大于 target 的元素
    int j = i - 1;
    // 未找到 target ,返回 -1
    if (j == -1 || nums[j] != target) {
        return -1;
    }
    // 找到 target ,返回索引 j
    return j;
}
  1. 转化为查找元素 我们知道,当数组不包含target时,最终i和j会分别指向首个大于、小于 target 的元素。因此,如图所示,我们可以构造一个数组中不存在的元素,用于查找左右边界:
  • 查找最左一个target :可以转化为查找 target - 0.5 ,并返回指针i。
  • 查找最右一个target :可以转化为查找 target + 0.5 ,并返回指针j。
    Alt text 代码在此省略,以下两点值得注意:
  • 给定数组不包含小数,这意味着我们无须关心如何处理相等的情况。
  • 因为该方法引入了小数,所以需要将函数中的变量target改为浮点数类型(Python无须改动)。

8. 重识搜索算法

搜索算法(searching algorithm)用于在数据结构(例如数组、链表、树或图)中搜索一个或一组满足特定条件的元素。搜索算法可根据实现思路分为以下两类:

  • 通过遍历数据结构来定位目标元素,例如数组、链表、树和图的遍历等。
  • 利用数据组织结构或数据包含的先验信息,实现高效元素查找,例如二分查找、哈希查找和二叉搜索树查找等。

8.1 暴力搜索

暴力搜索通过遍历数据结构的每个元素来定位目标元素:

  • "线性搜索"适用于数组和链表等线性数据结构。它从数据结构的一端开始,逐个访问元素,直到找到目标元素或到达另一端仍没有找到目标元素为止。
  • "广度优先搜索"和"深度优先搜索"是图和树的两种遍历策略。广度优先搜索从初始节点开始逐层搜索,由近及远地访问各个节点。深度优先搜索从初始节点开始,沿着一条路径走到头,再回溯并尝试其他路径,直到遍历完整个数据结构。

暴力搜索的优点是简单且通用性好,无须对数据做预处理和借助额外的数据结构。然而,此类算法的时间复杂度为O(n),其中n为元素数量,因此在数据量较大的情况下性能较差。

8.2 自适应搜索

自适应搜索利用数据的特有属性(例如有序性)来优化搜索过程,从而更高效地定位目标元素:

  • "二分查找"利用数据的有序性实现高效查找,仅适用于数组。
  • "哈希查找"利用哈希表将搜索数据和目标数据建立为键值对映射,从而实现查询操作。
  • "树查找"在特定的树结构(例如二叉搜索树)中,基于比较节点值来快速排除节点,从而定位目标元素。
    此类算法的优点是效率高,时间复杂度可达到O(logn)甚至O(1)。

8.3 搜索方法选取

给定大小为n的一组数据,我们可以使用线性搜索、二分查找、树查找、哈希查找等多种方法从中搜索目标元素。各个方法的工作原理如图所示:
Alt text 上述几种方法的操作效率与特性如表所示:

线性搜索二分查找树查找哈希查找
查找元素O(n)O(log⁡n)O(log⁡n)O(1)
插入元素O(1)O(n)O(log⁡n)O(1)
删除元素O(n)O(n)O(log⁡n)O(1)
额外空间O(1)O(1)O(n)O(n)
数据预处理/排序O(nlogn)建树O(n)建哈希表O(n)
数据是否有序无序有序有序无序

搜索算法的选择还取决于数据体量、搜索性能要求、数据查询与更新频率等。
线性搜索

  • 通用性较好,无须任何数据预处理操作。假如我们仅需查询一次数据,那么其他三种方法的数据预处理的时间比线性搜索的时间还要更长。
  • 适用于体量较小的数据,此情况下时间复杂度对效率影响较小。
  • 适用于数据更新频率较高的场景,因为该方法不需要对数据进行任何额外维护。

二分查找

  • 适用于大数据量的情况,效率表现稳定,最差时间复杂度为O(logn)。
  • 数据量不能过大,因为存储数组需要连续的内存空间。
  • 不适用于高频增删数据的场景,因为维护有序数组的开销较大。

哈希查找

  • 适合对查询性能要求很高的场景,平均时间复杂度为O(1)。
  • 不适合需要有序数据或范围查找的场景,因为哈希表无法维护数据的有序性。
  • 对哈希函数和哈希冲突处理策略的依赖性较高,具有较大的性能劣化风险。
  • 不适合数据量过大的情况,因为哈希表需要额外空间来最大程度地减少冲突,从而提供良好的查询性能。

树查找

  • 适用于海量数据,因为树节点在内存中是分散存储的。
  • 适合需要维护有序数据或范围查找的场景。
  • 在持续增删节点的过程中,二叉搜索树可能产生倾斜,时间复杂度劣化至O(n)。
  • 若使用AVL树或红黑树,则各项操作可在O(logn)效率下稳定运行,但维护树平衡的操作会增加额外的开销。