Java二分查找 | 期末满分备考指南：从入门到踩坑全覆盖（小白专用）

Java二分查找 | 期末满分备考指南：从入门到踩坑全覆盖（小白专用）

📌本文定位：专为Java程序设计/数据结构期末考的小白同学打造，不讲大厂面试、不扯考研408，只讲期末考试考点、写法规范、高频踩坑。看完本篇，二分查找编程题、选择题、改错题、分析题全部拿下，手写代码直接拿满分。

前言：为什么二分查找是期末必考题？

二分查找（折半查找）是所有高校「Java程序设计」「数据结构基础」课程的必考核心知识点，分值占比高，出题形式极其固定：

• 选择题：考循环条件、mid写法、时间复杂度、边界错误后果
• 填空题：补全代码中空缺的mid计算、边界更新、循环条件
• 改错题：找出给定二分代码中的2-3个典型错误
• 编程题：手写完整的二分查找函数
• 分析题：推导最坏时间复杂度

很多同学觉得「二分不就是每次砍一半吗，太简单了」，结果考试一写就错：要么循环条件写反，要么边界忘加1减1，要么mid溢出，甚至空指针异常直接0分。

二分查找的难点从来不是「折半思想」，而是边界细节的严谨性——差一个等号、差一个加减1，结果完全错误。这篇文章会从最基础的概念讲起，逐行拆解代码，把所有期末会考的坑全部讲透，配套手算演练，看完就能上考场。

一、先搞懂：二分查找到底是什么？

1.1 核心思想：折半排除

二分查找的本质是：在有序数组中，每次拿中间元素和目标对比，一次排除一半的搜索范围。

举个所有人都懂的生活例子：
猜数字游戏，数字范围1~100，你猜一个数，对方只说「大了」「小了」「对了」。
傻子才从1开始挨个猜，聪明人一定会先猜50：

• 如果说「大了」，说明答案在1~~49，直接排除51~~100（一半没了）
• 如果说「小了」，说明答案在51~~100，直接排除1~~49（一半没了）
• 如果说「对了」，直接结束

每猜一次，范围缩小一半，最多猜7次就能确定答案——这就是二分查找。

1.2 大前提：数组必须有序

⚠️期末考试第一考点：二分查找只能用在「有序数组」上，无序数组不能直接二分。

期末题目里一般会明确说「给定升序排列的整数数组」，如果题目没说有序，选择题里说「任意数组都能用二分查找」，直接打叉。

1.3 期末考的固定场景

99%的期末考题都是这个设定：

• 给定升序的int型整数数组
• 查找目标值target
• 如果找到，返回该元素对应的数组下标
• 如果找不到，返回-1
• 要求用非递归（循环）实现

我们整篇文章就围绕这个标准场景讲，把这一套吃透，期末直接默写。

二、满分模板逐行拆解：闭区间版二分查找

先上期末考试标准满分代码，这就是你考试直接写在卷子上的版本：

publicstaticintbinarySearch(int[]arr,inttarget){// 边界处理if(arr==null||arr.length==0){return-1;}intleft=0;intright=arr.length-1;while(left<=right){intmid=left+(right-left)/2;if(arr[mid]==target){returnmid;}elseif(arr[mid]<target){left=mid+1;}else{right=mid-1;}}return-1;}

接下来我们逐行、逐单词、逐符号讲明白：每一行是什么、为什么这么写、写错会怎么样。

2.1 方法定义行：public static int binarySearch(int[] arr, int target)

（1）public：访问修饰符

表示这个方法可以被其他类调用，期末考试写public就对了，是标准写法。不写也不算语法错，但建议写上，符合规范。

（2）static：静态修饰符

很多同学问「static有个屁用？」，一句话讲清楚：

• 加了static：这个方法属于「类」，不用new对象，直接用类名.方法名()就能调用
• 不加static：这个方法属于「对象」，必须先new一个类的实例，才能调用方法

二分查找是工具函数，不需要依赖对象的属性，所以固定加static。

💡考试提示：写不写static都不算错，代码逻辑对就给分。但教材里标准写法都带static，建议写上。

（3）int：返回值类型

我们要返回目标元素的数组下标，下标是整数，所以返回值类型是int。找不到返回-1，也是int类型，对应得上。

（4）binarySearch：方法名

这是Java的小驼峰命名规范：

• 第一个单词首字母小写（binary）
• 后面每个单词首字母大写（Search）
• 单词之间不空格、不下划线

为什么b小写、S大写？因为这是Java方法名的强制规范，就像中文写作文要写标点符号一样，属于代码规范分。

💡考试提示：就算你全写成小写binarysearch，语法不会报错，也能运行，但不规范。期末编程题一般有1-2分的规范分，建议按标准驼峰写。

（5）参数列表：int[] arr, int target

• int[] arr：传入的有序整数数组
• int target：要查找的目标值

这两个是形式参数（形参），相当于占位符，调用方法的时候会传进来实际的数组和数值。

2.2 边界处理：if (arr == null || arr.length == 0) return -1;

这一行是90%的小白第一次写都会漏掉的，也是期末改错题高频考点。

（1）arr == null：判断数组是否为空引用

什么是null？就是这个数组变量「没有指向任何实际的数组对象」，只是一个空名字。
这时候如果你敢写arr.length，程序直接报NullPointerException（空指针异常），直接崩掉。
所以必须先判断arr是不是null，是null就直接返回-1，不往后走。

（2）arr.length == 0：判断数组长度为0

数组对象存在，但是里面一个元素都没有，相当于一个空盒子。
这时候也不可能找到目标，直接返回-1。

（3）||：逻辑或运算符

规则：只要左右两边有一个条件成立，整体就成立。
也就是说：数组是null 或者 数组长度为0，只要满足其中一个，就执行return -1。

（4）⚠️ 顺序绝对不能反！

很多同学随手写成：

// 错误写法！会空指针异常if(arr.length==0||arr==null)

如果arr是null，程序会先执行arr.length == 0，直接访问null的length属性，当场空指针报错。

✅正确顺序：先判断null，再判断长度，这是期末选择题、改错题的经典坑。

2.3 左右指针初始化

intleft=0;intright=arr.length-1;

我们用两个整数变量left和right表示当前搜索范围的左右边界。

• left：左边界下标，初始是数组第一个元素的下标，也就是0
• right：右边界下标，初始是数组最后一个元素的下标，也就是数组长度-1（因为数组下标从0开始）

这里我们定义的是闭区间[left, right]：

闭区间的意思是：当前搜索范围包含left位置的元素，也包含right位置的元素，左右两个端点都算在内。

比如数组长度是5，下标0~4，初始left=0，right=4，搜索范围就是下标0到4，所有元素都包含。

💡考试提示：为什么right不是arr.length？因为arr.length是5的话，下标最大是4，arr[5]会越界。闭区间版本right必须是arr.length-1。

2.4 循环条件：while (left <= right)

这是二分查找最容易错的一行，没有之一。很多同学写成while (left < right)，然后丢分。

（1）为什么是<=而不是<？

因为我们是闭区间[left, right]，当left == right的时候，区间里还有一个元素（就是left和right指向的同一个位置），这个元素还没和target对比过，必须进入循环检查。

举个最简单的例子：数组只有一个元素[5]，查找5。

• left=0，right=0，left == right
• 如果循环条件是left <= right：进入循环，mid=0，arr[0]==5，返回0，正确
• 如果循环条件是left < right：0<0不成立，不进循环，直接返回-1，错误！

（2）什么时候循环结束？

当left > right的时候，闭区间里就没有元素了，说明整个数组都查完了，没找到目标，循环结束。

比如left=3，right=2，闭区间[3,2]，没有任何元素，循环终止。

💡期末口诀：闭区间，带等号，相等还有一个要检查。

2.5 中点计算：int mid = left + (right - left) / 2;

这一行有大学问，不是简单的求平均。

（1）为什么不写成(left + right) / 2？

很多同学数学里求中间数都是(a+b)/2，写代码也随手这么写——这是经典溢出bug，也是期末必考选择题。

Java里int类型的范围是-2147483648 ~ 2147483647（大概正负21亿）。
如果left和right都是很大的数，比如都是20亿，left + right就会超过int的最大值，结果溢出变成负数，mid就错了，程序直接乱掉。

（2）防溢出写法的原理

left + (right - left) / 2和(left + right)/2数学上完全相等，但计算过程不会溢出：

• 先算right-left，肯定比right小，不会溢出
• 除以2之后再加left，也不会溢出

举个数字例子：left=10，right=20

• 普通写法：(10+20)/2 = 15
• 防溢出写法：10 + (20-10)/2 = 10+5 = 15

结果完全一样，但后者永远不会溢出。

✅考试提示：期末写mid，一律写left + (right - left) / 2，这是标准满分写法。写(left+right)/2，严格的老师会扣1分。

（3）整数除法向下取整

Java里整数除以整数，结果是整数，向下取整。
比如left=0，right=3，mid = 0 + 3/2 = 1（不是1.5），这是正常的，二分查找中点偏左不影响正确性。

2.6 核心判断：三个分支

if(arr[mid]==target){returnmid;}elseif(arr[mid]<target){left=mid+1;}else{right=mid-1;}

（1）arr[mid] == target：找到了

拿数组mid位置的元素和目标值对比，相等就是找到了，直接返回mid这个下标。

⚠️小白易错点：不要写成mid == target！mid是下标（位置号），target是元素值，完全不是一个东西。

比如数组[2,4,6]，6在下标2的位置，你要比的是arr[2]==6，不是2==6。

（2）arr[mid] < target：目标在右边

中间元素比目标小，说明目标肯定在mid的右边。
因为数组是升序的，左边的都比mid小，所以mid左边（包括mid自己）都不可能是目标，直接把左边界移到mid的右边。

所以是left = mid + 1，mid本身要排除掉，因为已经对比过了。

（3）else：目标在左边

剩下的情况就是arr[mid] > target，中间元素比目标大，说明目标在mid左边。
同理，mid右边（包括mid自己）都不可能是目标，把右边界移到mid的左边。

所以是right = mid - 1，mid本身也要排除掉。

（4）为什么必须+1、-1？不写会怎么样？

很多同学偷懒写成left = mid、right = mid，这会导致死循环，期末改错题高频考点。

举个死循环例子：数组[1,3]，查找3。
初始left=0，right=1

• mid=0，arr[0]=1 < 3
• 如果left=mid（也就是0），那left还是0，right还是1，下一次mid还是0，永远循环下去

而left = mid + 1，left变成1，下一次mid=1，直接找到3，正确结束。

💡期末口诀：对比完mid就排除，左加右减别忘记。

2.7 循环结束：return -1;

循环走完了还没return，说明整个数组都找遍了，没找到目标，返回-1。

三、另一种写法：左闭右开区间版

除了上面讲的闭区间版，还有一种「左闭右开区间」的写法，期末部分教材也会讲，这里给你对比清楚，避免搞混。

3.1 左闭右开版本完整代码

publicstaticintbinarySearch(int[]arr,inttarget){if(arr==null||arr.length==0){return-1;}intleft=0;intright=arr.length;// 注意：这里是arr.length，不是-1while(left<right){// 注意：这里是<，没有=intmid=left+(right-left)/2;if(arr[mid]==target){returnmid;}elseif(arr[mid]<target){left=mid+1;}else{right=mid;// 注意：这里right=mid，不减1}}return-1;}

3.2 什么是左闭右开[left, right)

左闭右开的意思是：搜索范围包含left位置的元素，不包含right位置的元素，right指向搜索范围的下一个位置。

所以初始的时候，right = arr.length，因为数组最后一个元素的下标是arr.length-1，right指向它的下一个位置，刚好把所有元素都包含在[0, arr.length)里。

3.3 为什么循环条件是left < right

因为当left == right的时候，[left, right)这个区间里就没有元素了，直接退出循环，所以不用写等号。

3.4 为什么right = mid，不减1

因为右边界是开区间，不包含right本身。
当arr[mid] > target的时候，目标在左边，mid位置不可能是目标，所以把右边界设为mid，刚好把mid排除在区间之外（因为右开）。

3.5 两套写法对比表

期末考试最忌讳两套混搭，下面这个表直接记死：

3.6 考试选哪个？

✅强烈推荐闭区间版，原因：

1. 逻辑直观，和数学上的区间概念一致，好记
2. 大部分高校教材、课件用的都是闭区间版
3. 不容易写错，混搭概率低

💡考试提示：认准一套写到底，千万别混着写。比如闭区间初始right=arr.length-1，循环条件却写left<right，必错。

四、期末必考：时间复杂度与空间复杂度

复杂度分析是期末理论题必考题，一般占3-5分，要么选择题，要么分析推导题。

4.1 先搞懂：什么是大O表示法

大O表示法用来衡量算法的「时间/空间随数据规模增长的快慢」，只看最高量级，忽略常数和低阶项。

• O(1)：常数级，数据规模变大，时间不变
• O(n)：线性级，数据翻几倍，时间翻几倍
• O(log n)：对数级，数据翻几倍，时间只增加一点点
• O(n²)：平方级，数据翻几倍，时间翻平方倍

4.2 二分查找最坏时间复杂度推导

最坏情况：目标不在数组里，或者在数组的最后一个才找到，需要把区间缩到空为止。

我们一步步推：

1. 初始搜索区间长度：n
2. 第1次比较后，排除一半，区间长度变成 n/2
3. 第2次比较后，再排除一半，区间长度变成 n/4
4. 第3次比较后，区间长度变成 n/8
5. ……
6. 第k次比较后，区间长度变成 n / 2^k

什么时候结束？当区间里没有元素的时候，也就是 n / 2^k< 1，也就是2^k> n的时候。
我们取极限情况，区间长度变成1的时候，还需要再比较1次：
n2k=1 \frac{n}{2^k} = 12kn​=1
两边取对数：
k=log⁡2n k = \log_2 nk=log2​n

也就是说，最坏情况下最多比较 log₂n 次，所以最坏时间复杂度是 O(log n)。

4.3 最好时间复杂度

最好情况：第一次mid就命中目标，只需要1次比较。
所以最好时间复杂度是 O(1)。

4.4 平均时间复杂度

平均情况也是 O(log n)，因为每次都能排除一半，整体就是对数级别。

4.5 空间复杂度

我们写的循环版二分查找，只用到了left、right、mid三个变量，额外开辟的空间是固定的，和数据规模n没关系。
所以空间复杂度是 O(1)，也叫「原地算法」。

💡考试提示：如果是递归版二分查找，空间复杂度是O(log n)，因为递归调用栈的深度是logn层。期末没说递归的话，默认循环版，空间复杂度O(1)。

4.6 期末常见错误说法辨析

选择题常考以下错误说法，直接记结论：

• ❌ 二分查找时间复杂度是O(n)：错，那是顺序查找
• ❌ 二分查找最坏时间复杂度是O(n/2)：错，大O要去掉常数
• ❌ 二分查找空间复杂度是O(n)：错，循环版是常数空间
• ✅ 二分查找比顺序查找快，数据量越大优势越明显：对

五、期末高频踩坑点汇总（选择/改错题必出）

这一章是提分重点，期末考试的坑基本都在这里了，每个坑都给你讲清楚错误写法、后果、正确写法。

⚠️ 坑1：不做非空判断，空指针异常

• 错误代码：上来直接定义left=0，right=arr.length-1，不判断arr==null
• 后果：传入null的时候直接报空指针，函数崩溃
• 正确写法：开头第一行就判断arr == null || arr.length == 0
• 考试考法：改错题找错误，选择题问哪种情况会异常

⚠️ 坑2：循环条件写错，<=写成<

• 错误代码：while (left < right)
• 后果：漏掉left==right位置的元素，数组末尾的元素可能找不到
• 正确写法：闭区间必须写left <= right
• 考试考法：选择题问哪个是正确的循环条件，填空题补全条件

⚠️ 坑3：边界更新忘加1减1，死循环

• 错误代码：left = mid或者right = mid
• 后果：区间长度为2的时候陷入死循环，程序卡死
• 正确写法：left = mid + 1，right = mid - 1
• 考试考法：改错题找错误，选择题问什么情况会死循环

⚠️ 坑4：mid计算用(left+right)/2，整型溢出

• 错误代码：int mid = (left + right) / 2;
• 后果：数组很大的时候溢出，mid变成负数，数组越界
• 正确写法：int mid = left + (right - left) / 2;
• 考试考法：选择题问哪种写法更安全，改错题找错误

⚠️ 坑5：混淆下标和元素值

• 错误代码：if (mid == target)
• 后果：把位置号和元素值对比，逻辑完全错误
• 正确写法：if (arr[mid] == target)
• 考试考法：编程题粗心写错，改错题找错误

⚠️ 坑6：right初始化错误

• 错误代码：闭区间版写成right = arr.length;
• 后果：第一次循环访问arr[mid]的时候数组越界
• 正确写法：闭区间right = arr.length - 1
• 考试考法：选择题问数组越界的原因

⚠️ 坑7：数组无序就用二分

• 错误说法：任意数组都可以用二分查找
• 后果：结果完全错误，找不到正确的元素
• 正确结论：二分查找前提是数组有序
• 考试考法：选择题判断题

⚠️ 坑8：判断顺序写反，空指针

• 错误代码：if (arr.length == 0 || arr == null)
• 后果：arr为null时先访问length，空指针异常
• 正确写法：先判断null，再判断长度
• 考试考法：选择题问哪个写法正确

六、代码规范与注释：期末评分隐形分

很多同学问：考试要不要写注释？@param要不要写？不写会不会扣分？

6.1 Javadoc注释（/** … */）

就是开头这种：

/** * 二分查找（升序数组） * @param arr 有序整数数组 * @param target 目标值 * @return 目标值下标，不存在返回 -1 */

• @param：参数说明，解释每个参数是什么
• @return：返回值说明，解释返回结果的含义

这叫Javadoc文档注释，用来自动生成API文档，对代码运行没有任何影响，编译器直接忽略。

✅考试结论：

• 编程题可以完全不写，不会扣分
• 写了显得规范，老师印象分可能更好，但不是必须
• 期末时间紧张的话，直接删掉，把逻辑写对最重要

6.2 单行注释（// …）

比如// 边界处理、// 防溢出写法这种。

✅考试结论：

• 不用每一行都写，关键地方写一两个就行
• 实在没时间，全不写也没问题，逻辑正确是核心
• 建议至少写个边界处理、循环条件的注释，方便自己检查

6.3 命名规范

期末编程题一般有1分的规范分，记住这几个就行：

• 方法名：小驼峰，比如binarySearch
• 变量名：小驼峰，比如left、right、target
• 类名：大驼峰，比如BinarySearch
• 不要用拼音、不要乱起名，比如chaZhao、a、b

七、手算演练：期末选择题填空题必杀技

期末考试特别喜欢给一个数组，让你手动走二分流程，数比较次数、返回下标。这种题只要一步步走，绝对不会错。

例题1：基础查找（目标在数组中）

题目：升序数组[1, 3, 5, 7, 9, 11, 13]，用二分查找查找11，需要比较几次？返回下标是多少？

一步步走：
初始：left=0，right=6（数组长度7，7-1=6）

1. 第1次比较：
   mid = 0 + (6-0)/2 = 3
   arr[3] = 7
   7 < 11 → 目标在右边，left = 3 + 1 = 4
2. 第2次比较：
   left=4，right=6
   mid = 4 + (6-4)/2 = 5
   arr[5] = 11
   11 == 11 → 找到，返回下标5

答案：比较2次，返回下标5。

例题2：目标不存在

题目：升序数组[2, 4, 6, 8, 10]，查找3，最后返回什么？比较了几次？

一步步走：
初始：left=0，right=4

1. 第1次：
   mid=0 + 4/2 = 2
   arr[2]=6
   6 > 3 → 目标在左边，right = 2-1 = 1
2. 第2次：
   left=0，right=1
   mid=0 + 1/2 = 0
   arr[0]=2
   2 < 3 → 目标在右边，left = 0+1 = 1
3. 第3次：
   left=1，right=1，满足<=，进入循环
   mid=1 + 0/2 = 1
   arr[1]=4
   4 > 3 → right = 1-1 = 0

循环结束：left=1，right=0，left>right，退出循环，返回-1

答案：返回-1，比较了3次。

例题3：单元素数组

题目：数组[5]，查找5，循环会进几次？

• left=0，right=0，0<=0成立，进入循环
• mid=0，arr[0]==5，返回0

答案：进1次循环，正确找到。

如果循环条件写成left<right，一次都不进，直接返回-1，错误。

💡 手算技巧

1. 每一步都把left和right的值写出来，别心算
2. mid永远用left + (right-left)/2算，别想当然
3. 每次更新完边界，检查一下区间对不对
4. 最后left>right才结束，别提前停

八、递归版二分查找（选学）

部分高校期末会考递归实现，这里简单给一下模板，没学过的可以跳过，优先掌握循环版。

递归版完整代码

publicstaticintbinarySearch(int[]arr,inttarget){if(arr==null||arr.length==0){return-1;}returnbinarySearch(arr,target,0,arr.length-1);}// 递归辅助方法privatestaticintbinarySearch(int[]arr,inttarget,intleft,intright){// 递归终止条件：区间为空if(left>right){return-1;}intmid=left+(right-left)/2;if(arr[mid]==target){returnmid;}elseif(arr[mid]<target){// 递归查右半部分returnbinarySearch(arr,target,mid+1,right);}else{// 递归查左半部分returnbinarySearch(arr,target,left,mid-1);}}

递归版说明

1. 递归终止条件：left > right，和循环版结束条件一样
2. 每次递归把新的left和right传进去
3. 时间复杂度还是O(log n)
4. 空间复杂度O(log n)，因为递归栈最多有logn层

💡考试提示：题目没说用递归，一律写循环版。递归容易栈溢出，而且手写容易写错参数。

九、期末编程题答题技巧：怎么写不丢分

二分查找编程题是送分题，但很多同学因为细节丢分，这里给你答题步骤，按这个写，满分稳了。

答题八步走

1. 先写方法头

publicstaticintbinarySearch(int[]arr,inttarget){}

先把架子搭好，返回值、方法名、参数都写对，规范分先拿到。
2.写边界处理

if(arr==null||arr.length==0){return-1;}

空判断先写上，避免后面忘，这是基础分。
3.初始化左右指针

intleft=0;intright=arr.length-1;

闭区间，right记得减1。
4.写循环框架

while(left<=right){}return-1;

循环条件<=，最后返回-1，先写好。
5.写mid计算

intmid=left+(right-left)/2;

防溢出写法，别写(left+right)/2。
6.写三个分支

if(arr[mid]==target){returnmid;}elseif(arr[mid]<target){left=mid+1;}else{right=mid-1;}

记得+1和-1，别漏。
7.检查三遍

• 循环条件是<=吗？
• left和right更新有加减1吗？
• mid是防溢出写法吗？

8. 简单用例自测
   脑子里过一下：
   • 空数组：返回-1 ✔️
   • 单元素数组找得到：返回0 ✔️
   • 单元素找不到：返回-1 ✔️
   • 目标在开头：能找到 ✔️
   • 目标在结尾：能找到 ✔️

都没问题，这道题就满分了。

十、期末常见题型汇总与答题模板

10.1 选择题

• 常考方向：复杂度、循环条件、mid写法、错误后果
• 答题技巧：记住闭区间的全套规则，用排除法。
  • 看到mid是(left+right)/2，优先排除
  • 看到循环条件left<right（闭区间题），优先排除
  • 看到时间复杂度O(n)，直接排除

10.2 填空题

• 常考方向：补全mid、补全边界更新、补全循环条件
• 答题技巧：先看是闭区间还是开区间，然后按对应模板填。
  • 闭区间：循环填<=，right更新填mid-1
  • 左闭右开：循环填<，right更新填mid

10.3 改错题

• 常考错误：空判断、循环条件、边界加减1、mid溢出
• 答题技巧：按顺序找：
  1. 有没有非空判断？顺序对不对？
  2. 循环条件对不对？
  3. mid写法对不对？
  4. 边界更新有没有+1-1？
     一般就是这4个里面的2-3个。

10.4 分析题

• 常考：推导最坏时间复杂度
• 答题模板（直接背）：>

二分查找最坏情况下，目标不存在，每次比较排除一半元素，搜索区间长度从n依次变为n/2、n/4……直到区间为空。设需要k次比较，则n/2^k= 1，解得k = log₂n。因此最坏时间复杂度为O(log n)。

10.5 编程题

• 答题模板：直接默写第二章的闭区间满分代码，按第九章的步骤写，保证不丢分。

十一、考前核心速记

最后用几句话把所有重点再串一遍，考前看一眼就行：

✅ 二分前提：数组有序
✅ 闭区间三板斧：right初始length-1、循环条件<=、边界更新mid±1
✅ mid防溢出：left + (right-left)/2
✅ 空判断：先null后长度，||逻辑或
✅ 最坏时间复杂度O(log n)，空间复杂度O(1)
✅ 别把下标和元素值搞混

结尾

二分查找是期末算法题里最简单、最固定的一道题，没有之一。它不需要复杂的逻辑，只需要严谨的细节——差一个等号、差一个加减1，就是0分和满分的区别。

只要你把这篇文章里的闭区间模板记牢，把所有坑都避开，考试的时候稳稳当当写出来，这道题就是送分题。

祝大家期末Java考试顺利，二分查找全拿满分！

作者：培风图南以星河揽胜
专注期末备考干货，只讲考试能用的知识