二分查找算法详解

最新推荐文章于 2025-08-06 17:01:48 发布
原创 最新推荐文章于 2025-08-06 17:01:48 发布 · 669 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #java #数据结构

引言

在计算机科学中，查找是一种常见的操作，而二分查找（Binary Search）是一种高效的查找算法，特别适用于有序数据集。

二分查找算法的核心思想是通过将查找区间反复折半，每次比较都能排除一半的搜索空间，从而大大提高查找效率。与线性查找相比，二分查找的时间复杂度为O(log n)，这使得它在处理大规模数据时表现出色。

一、二分查找算法原理

1. 基本概念

二分查找（Binary Search），也称折半搜索，是一种在有序数组中查找特定元素的高效算法。它通过将搜索区域反复减半来快速定位目标元素，每次比较都使搜索范围缩小一半。

2. 算法思想

二分查找的基本思路如下：

  1. 确定查找范围的起始点（low）和结束点（high）
  2. 计算中间位置（mid）：mid = low + (high - low) / 2
  3. 比较中间元素与目标值：
    • 如果相等，则查找成功，返回索引
    • 如果目标值小于中间元素，则在左半部分继续查找（更新high = mid - 1）
    • 如果目标值大于中间元素，则在右半部分继续查找（更新low = mid + 1）
  4. 重复上述步骤，直到找到目标元素或确定元素不存在（low > high）

3. 二分查找过程

以数组 [1, 3, 5, 7, 9, 11, 13, 15] 为例，查找元素 7 的过程：

  1. 初始状态：low = 0, high = 7, mid = 3
    • arr[mid] = arr[3] = 7，等于目标值，查找成功，返回索引 3

如果查找元素 10：

  1. 初始状态：low = 0, high = 7, mid = 3
    • arr[mid] = arr[3] = 7，小于目标值 10，在右半部分查找
    • 更新 low = mid + 1 = 4
  2. 第二次查找：low = 4, high = 7, mid = 5
    • arr[mid] = arr[5] = 11，大于目标值 10，在左半部分查找
    • 更新 high = mid - 1 = 4
  3. 第三次查找：low = 4, high = 4, mid = 4
    • arr[mid] = arr[4] = 9，小于目标值 10，在右半部分查找
    • 更新 low = mid + 1 = 5
  4. 第四次查找：low = 5, high = 4
    • 由于 low > high，查找结束，目标值不存在，返回 -1

二、Java实现二分查找

1. 递归实现

递归方式实现二分查找，代码简洁但需要额外的栈空间：

/**
 * 二分查找算法的递归实现
 * @param arr 有序数组（假设为升序）
 * @param low 查找范围的起始索引
 * @param high 查找范围的结束索引
 * @param target 目标值
 * @return 目标值在数组中的索引，如果不存在则返回-1
 */
public static int binarySearchRecursive(int[] arr, int low, int high, int target) {
    // 基本判断：如果low大于high，说明查找范围为空，目标值不存在
    if (low > high) {
        return -1;
    }
    
    // 计算中间位置，避免整数溢出
    int mid = low + (high - low) / 2;
    
    // 找到目标值
    if (arr[mid] == target) {
        return mid;
    }
    // 目标值在左半部分
    else if (arr[mid] > target) {
        return binarySearchRecursive(arr, low, mid - 1, target);
    }
    // 目标值在右半部分
    else {
        return binarySearchRecursive(arr, mid + 1, high, target);
    }
}

2. 非递归实现

非递归（迭代）方式实现二分查找，避免了递归调用的栈开销：

/**
 * 二分查找算法的非递归实现
 * @param arr 有序数组（假设为升序）
 * @param target 目标值
 * @return 目标值在数组中的索引，如果不存在则返回-1
 */
public static int binarySearchIterative(int[] arr, int target) {
    int low = 0;
    int high = arr.length - 1;
    
    while (low <= high) {
        // 计算中间位置，避免整数溢出
        int mid = low + (high - low) / 2;
        
        // 找到目标值
        if (arr[mid] == target) {
            return mid;
        }
        // 目标值在左半部分
        else if (arr[mid] > target) {
            high = mid - 1;
        }
        // 目标值在右半部分
        else {
            low = mid + 1;
        }
    }
    
    // 未找到目标值
    return -1;
}

3. 代码测试

下面是一个完整的测试类，用于验证二分查找算法的正确性：

/**
 * 二分查找算法测试类
 */
public class BinarySearchTest {
    public static void main(String[] args) {
        // 测试数组
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15};
        
        // 测试递归实现
        System.out.println("递归实现测试：");
        System.out.println("查找元素7的索引：" + binarySearchRecursive(arr, 0, arr.length - 1, 7));
        System.out.println("查找元素10的索引：" + binarySearchRecursive(arr, 0, arr.length - 1, 10));
        
        // 测试非递归实现
        System.out.println("\n非递归实现测试：");
        System.out.println("查找元素7的索引：" + binarySearchIterative(arr, 7));
        System.out.println("查找元素10的索引：" + binarySearchIterative(arr, 10));
    }
    
    // 这里包含上面的递归和非递归方法实现...
}

运行结果：

递归实现测试：
查找元素7的索引：3
查找元素10的索引：-1

非递归实现测试：
查找元素7的索引：3
查找元素10的索引：-1

三、二分查找算法分析

1. 时间复杂度

二分查找的时间复杂度分析：

  • 最坏情况：O(log n) - 需要进行log₂n次比较才能确定元素是否存在
  • 最好情况：O(1) - 第一次比较就找到目标元素
  • 平均情况：O(log n) - 平均需要log₂n次比较

每次比较后，查找范围缩小为原来的一半，这种对数级的时间复杂度使得二分查找在处理大规模数据时非常高效。

2. 空间复杂度

二分查找的空间复杂度取决于实现方式：

  • 非递归实现：O(1) - 只需要常数级别的辅助空间（几个变量）
  • 递归实现：O(log n) - 递归调用栈的深度为log₂n

3. 优缺点分析

优点：

  • 查找效率高，时间复杂度为O(log n)
  • 适用于大规模数据查找
  • 实现相对简单

缺点：

  • 要求数据必须有序，如果数据经常变动需要维护有序性
  • 只适用于数组等支持随机访问的数据结构
  • 数据量较小时，可能不如线性查找直观

四、二分查找的变体

在实际应用中，我们经常需要处理一些特殊情况，如数组中包含重复元素，或者需要查找特定条件的元素。以下是几种常见的二分查找变体。

1. 查找第一个等于目标值的元素

当数组中包含重复元素时，标准的二分查找只能返回其中一个等于目标值的元素，而不一定是第一个。以下是查找第一个等于目标值的元素的实现：

/**
 * 查找第一个等于目标值的元素
 * @param arr 有序数组（可能包含重复元素）
 * @param target 目标值
 * @return 第一个等于目标值的元素索引，如果不存在则返回-1
 */
public static int findFirstEqual(int[] arr, int target) {
    int low = 0;
    int high = arr.length - 1;
    int result = -1;
    
    while (low <= high) {
        int mid = low + (high - low) / 2;
        
        if (arr[mid] == target) {
            // 记录当前找到的位置，但不返回，继续向左查找
            result = mid;
            high = mid - 1;
        } else if (arr[mid] > target) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    
    return result;
}

2. 查找最后一个等于目标值的元素

类似地，我们可以实现查找最后一个等于目标值的元素：

/**
 * 查找最后一个等于目标值的元素
 * @param arr 有序数组（可能包含重复元素）
 * @param target 目标值
 * @return 最后一个等于目标值的元素索引，如果不存在则返回-1
 */
public static int findLastEqual(int[] arr, int target) {
    int low = 0;
    int high = arr.length - 1;
    int result = -1;
    
    while (low <= high) {
        int mid = low + (high - low) / 2;
        
        if (arr[mid] == target) {
            // 记录当前找到的位置，但不返回，继续向右查找
            result = mid;
            low = mid + 1;
        } else if (arr[mid] > target) {
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    
    return result;
}

3. 查找第一个大于等于目标值的元素

这个变体在查找插入位置时特别有用：

/**
 * 查找第一个大于等于目标值的元素
 * @param arr 有序数组
 * @param target 目标值
 * @return 第一个大于等于目标值的元素索引，如果不存在则返回-1
 */
public static int findFirstGreaterOrEqual(int[] arr, int target) {
    int low = 0;
    int high = arr.length - 1;
    int result = -1;
    
    while (low <= high) {
        int mid = low + (high - low) / 2;
        
        if (arr[mid] >= target) {
            // 记录当前找到的位置，但不返回，继续向左查找
            result = mid;
            high = mid - 1;
        } else {
            low = mid + 1;
        }
    }
    
    return result;
}

4. 查找最后一个小于等于目标值的元素

这个变体在范围查询中很有用：

/**
 * 查找最后一个小于等于目标值的元素
 * @param arr 有序数组
 * @param target 目标值
 * @return 最后一个小于等于目标值的元素索引，如果不存在则返回-1
 */
public static int findLastLessOrEqual(int[] arr, int target) {
    int low = 0;
    int high = arr.length - 1;
    int result = -1;
    
    while (low <= high) {
        int mid = low + (high - low) / 2;
        
        if (arr[mid] <= target) {
            // 记录当前找到的位置，但不返回，继续向右查找
            result = mid;
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }
    
    return result;
}

五、二分查找的应用场景

二分查找算法在实际开发中有广泛的应用：

  • 数据库索引：B树和B+树等数据库索引结构中使用了二分查找的思想
  • 查找插入位置：在有序数组中找到合适的插入位置以保持数组有序
  • 近似查找：查找最接近目标值的元素
  • 二分答案：在一些算法设计中，通过二分查找确定最优解
  • API设计：Java中的Arrays.binarySearch()和Collections.binarySearch()等方法

六、注意事项与优化技巧

在实现和使用二分查找时，有几个重要的注意事项：

  1. 中值计算：使用mid = low + (high - low) / 2而非mid = (low + high) / 2，后者在处理大数组时可能导致整数溢出。

  2. 边界条件：注意循环条件是low <= high而不是low < high，确保能处理单个元素的情况。

  3. 预处理检查：在进行二分查找前，可以先检查数组是否为空、目标值是否在数组范围内，以提高效率。

  4. 有序性保证：确保输入数组已经排序，否则二分查找的结果将不可预测。

总结

二分查找是一种高效的查找算法，特别适用于有序数组。它的时间复杂度为O(log n)，使其在处理大规模数据时表现出色。

在实际应用中，我们需要根据具体场景选择合适的二分查找变体，并注意处理边界条件和特殊情况。掌握二分查找算法不仅能提高代码效率，还能帮助我们更好地理解算法设计的思想和技巧。

无糖星轨
关注
二分查找算法详解与实现.zip
06-17
通过阅读“二分查找算法详解与实现.pdf”和“项目说明.pdf”，你可以深入理解二分查找的原理，看到具体的应用实例，以及可能遇到的挑战和解决方案。这些文档将帮助你更好地掌握这一重要算法，并能够在实际工作中灵活...
JS二分查找算法详解
11-28
二分法查找，也称折半查找，是一种在有序数组中查找特定元素的搜索算法。查找过程可以分为以下步骤： （1）首先，从有序数组的中间的元素开始搜索，如果该元素正好是目标元素（即要查找的元素），则搜索过程结束，...
java二分查找算法详解
2301_81490350的博客
12-18 1566
例如，在数组[1, 2, 3, 4, 5, 6, 7, 8, 9, 9] 中查找 9，我们希望返回索引 9。
Java二分查找算法详解
qq_44717657的博客
11-26 5890
二分查找引言什么是二分二分的定义及二分查找算法的思路二分定义二分查找算法的思路二分查代码具体实现伪代码实现代码 引言 假如给你一个有序数组，然后给你一个数，让你去数组中找出该元素。如果数组中存在该元素，则返回该数在数组中的下标，如果不存在则返回-1。 如果是你，你会怎么做？给你三秒钟时间考虑，1、2、3，时间到。 是顺序查找吗？写一个循环，遍历整个数组去和目标数比较？那如果数据量很大，而且需找到的数在数组的最后面，那是不是太慢了？比如一个从0开始到9999的数组，我要查找9999这个数，是不是要比较9999
数据结构实战：二分查找算法详解
weixin_42594419的博客
05-16 995
在数据结构和算法的世界中，查找操作是基础且十分重要的功能。它被广泛用于优化查询效率，尤其是在处理大量数据时。二分查找，顾名思义，是一种在有序数组中查找特定元素的高效算法。它之所以强大，是因为每次查找都将搜索范围缩小一半，大幅提升了查找的效率。二分查找的核心原理是将数组分为两半，通过比较数组的中间元素与目标值，决定是继续在左半部分查找还是右半部分查找。通过这种分而治之的策略，极大地减少了查找所需的比较次数。在理想情况下，二分查找的时间复杂度可以达到O(log n)，这里n。
二分查找算法详解（经典二分和左右边界查找）
JM-Nie的博客
02-09 8216
这篇文章主要讲解经典的二分查找算法以及二分查找算法的变种（左右边界的查找）。 二分查找算法的基本思想：在有序表中，每次都取中间记录作为比较对象，若给定值与中间记录的关键字相等则查找成功，返回该关键字的索引；若给定值小于中间记录的关键字，则在中间记录的左半区继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。不断重复上诉过程，直到查找成功，或者所有查找区域无记录，查找失败为止，返回一个值代表没有找到。
二分查找算法 (算法详解+模板+例题)
weixin_74461263的博客
10-21 8539
二分查找算法并不是针对在数组有序的情况下,通过后面的题我们就会知道实际上只要是满足"二段性"的题目,都可以通过二分查找算法来实现我们可以分成三种情况朴素的二分查找(最简单,但是基本不涉及)查找左边界的二分查找查找右边界的二分查找第二第三基本是万能的,但细节较多我们来看一张二分查找与遍历查找的效率对比图。题目链接我们先寻找左端点:通过上图,我们会很容易地看出,左端点将数组划分为左区间和右区间,这不就就是我们在一开始就强调的"二段性",那么我们就可以利用二分查找来寻找这个左端点。
【java算法】二分查找算法详解
热门推荐
CynthiaJuJu的博客
09-02 1万+
hello，大家好！我是磨磨唧唧小蘑菇~ 最近在努力的复习一些基本的算法，本期就以java的二分查找算法进行详细的概述（之前面试的时候，手写算法被坑过，一把泪啊）。进入正题吧~ 一、二分查找算法的介绍 二分查找，又名折半查找。顾名思义，一半一半去找目标值~ 对于一个有序的升序列表，将目标值与表中间的值进行对比： 1）如果目标值与表中间的值相等，则直接返回表中间的值即可 2）如果目标值与表中间的值不相等，则将两者进行大小比较，从而分成两个表： （1）如果目标值小于中间值，说明目标值在中间值往左.
Java 二分查找算法详解及通用实现模板案例示范
J老熊
10-15 1465
本文详细讲解了二分查找的基本原理、通用实现模板及其变体，还结合了实际案例展示了其应用场景。通过这些内容，相信你已经对二分查找有了更深入的理解，并能灵活地将其应用于实际项目中。
二分查找(算法详解+模板+例题)
Alex_Fufu的博客
08-17 6874
二分法（Bisection method） 即一分为二的方法. 设[a，b]为R的闭区间. 逐次二分法就是造出如下的区间序列([an，bn])：a0=a，b0=b，且对任一自然数n，[an+1，bn+1]或者等于[an，cn]，或者等于[cn，bn]，其中cn表示[an，bn]的中点。
二分查找算法详解（附代码）
阿杰么的博客
07-12 2052
学习的第一个算法
Python搜索算法-二分查找算法详解
04-10
Python搜索算法——二分查找算法详解
贝叶斯分类算法详解：从数学原理到实践应用
weixin_73958875的博客
08-05 613
本文系统介绍了贝叶斯分类算法及其应用。首先阐述了贝叶斯定理的数学原理，包括朴素贝叶斯的特征独立性假设及其三种主要实现形式（高斯、多项式和伯努利贝叶斯）。然后详细解析了Scikit-learn中贝叶斯分类器的API参数和使用方法，包括关键参数调优建议。最后通过垃圾邮件分类案例展示了实际应用流程，并分析了贝叶斯算法在计算效率、内存消耗等方面的优势，以及特征独立性假设带来的局限性。全文为读者提供了从理论到实践的完整贝叶斯分类器应用指南。
Transformer实战——Transformer分词算法详解
盼小辉丶的博客
08-05 717
本文系统性地介绍了 Transformer 模型中的分词算法。我们首先分析了传统分词方法的局限性，进而深入探讨了 BPE、WordPiece 和 SentencePiece 这三种子词分词算法的工作原理和适用场景。通过 Hugging Face tokenizers 库的实践，完整展示了分词器从数据预处理到模型训练的全流程。
USACO 2025 JAN Table Recovery S 题解
2401_84512298的博客
08-06 886
举例+思路+实现，保姆级详细题解
非机动车识别mAP↑28%！陌讯多模态融合算法在智慧交通的实战解析
最新发布
2501_92472966的博客
08-06 421
陌讯多模态融合算法显著提升非机动车识别性能，在边缘计算设备上实现[email protected]达89.1%，较基线提升28%。该方案通过偏振特征增强、HDR补偿等技术有效解决强光/逆光等复杂场景识别难题，使小目标识别率提升46.1%，早晚高峰漏检率降低85.3%。同时提供INT8量化等边缘部署优化方案，内存占用减少60%且保持精度损失<0.5%。实测数据表明，该技术可显著提升智慧交通场景下的非机动车识别准确率。
力扣热题100——子串
weixin_45789915的博客
08-05 241
我的暴力双指针解法超时，并且此方法仅适用于全非负数组！
无人机开发分享——基于行为树的无人机集群机载自主决策算法框架搭建及开发
Vesan的博客
08-06 256
* 在之前的开发分享中，我们分享了机载端开发任务管理、协同控制、无人机平台接口等一系列模块软件，但是要想实现真正的无人机高度智能化，机载的自主决策模块功能必不可少。机载自主决策模块主要实现无人机集群任务过程中地面任务获取分析、战场实时态势分析与自主决策，可在断连或自主模式时对作业中的无人机集群进行决策与控制，减少地面交互，提升任务效率。下面我们对机载自主决策模块的开发进行介绍。**
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值