目录
一、简介
1.1、特点
二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，二分查找有两个要求：
- 线性表必须采用顺序存储结构
- 线性表中元素按关键字有序排列
1.2、实现思路
二分查找查询的大致思路：每次取线性表中间位置的值与待查关键字的值进行比较：
- 如果待查关键字的值比中间位置的值小，则在前半部分循环这个查找的过程
- 如果待查关键字的值比中间位置的值大，则在后半部分循环这个查找的过程
- 直到待查关键字的值和中间位置的值相等，否则线性表中没有待查的关键字
二、maven依赖
pom.xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.6.0</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.14</version>
</dependency>
</dependencies>
本文中springboot的版本还是2.6.0
三、递归方式
3.1、代码实现
/**
* 二分查找法
*
* @param arr 要查找的数组（必须采用顺序存储结构，而且表中元素按关键字有序排列）
* @param startIndex 从要查找数组的哪个索引开始
* @param endIndex 从要查找数组的哪个索引结束
* @param targetValue 要查找的值
* @return 如果查询到则返回该数据在数组中的索引
* 如果未查到则返回-1
*/
public static int binarySearch(int[] arr, int startIndex, int endIndex, int targetValue) {
if (startIndex < 0 || endIndex >= arr.length) {
log.info("索引值应该大于-1，并且小于数组的长度减1，此时的开始索引：{},结束索引：{}", startIndex, endIndex);
return -1;
}
if (startIndex > endIndex) {
log.info("开始索引必须大于结束索引,此时的开始索引：{},结束索引：{}", startIndex, endIndex);
return -1;
}
if (targetValue < arr[startIndex]) {
log.info("要查询的值【{}】小于数组的最小值【{}】", targetValue, arr[startIndex]);
return -1;
}
if (targetValue > arr[endIndex]) {
log.info("要查询的值【{}】大于数组的最小值【{}】", targetValue, arr[endIndex]);
return -1;
}
log.info("从索引start={}到索引end={},要检索的数组范围为：{}", startIndex, endIndex, Arrays.copyOfRange(arr, startIndex, endIndex + 1));
//获取中间值及其索引
int midIndex = (startIndex + endIndex) / 2;
int midValue = arr[midIndex];
log.info("此时要检索的数组的中间值为：{}，索引为：{}", midValue, midIndex);
if (targetValue < midValue) {
log.info("目标元素【{}】小于中间值【{}】,接下来从索引start={}到索引end={}进行检索", targetValue, midValue, startIndex, midIndex - 1);
return binarySearch(arr, startIndex, midIndex - 1, targetValue);
} else if (targetValue > midValue) {
log.info("目标元素【{}】大于中间值【{}】,接下来从索引start={}到索引end={}进行检索", targetValue, midValue, midIndex + 1, endIndex);
return binarySearch(arr, midIndex + 1, endIndex, targetValue);
} else {
log.info("目标元素【{}】等于中间值【{}】,找到数据,索引值为：{}", targetValue, midValue, midIndex);
return midIndex;
}
}
public static void main(String[] args) {
//注意此数组应该是线性的，递增或者递减（本文是递增）
//如果是递减得修改算法里的条件判断，思路一样
int int[] arr = new int[]{3, 7, 8, 13, 14, 16, 18, 28, 30};
//调用递归方式的二分查找法
int i = binarySearch(arr, 0, arr.length-1, 8);
log.info("递归方式实现二分查找法查询结果：{}", i);
}
3.2、数据流向过程
假设我们在数组中查找 8 ，那么查找的数据流程如下表格：（蓝色的表示要查找的范围）
| 数组索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|---|
| 原数组元素（查找8） | 3 | 7 | 8 | 13 | 14 | 16 | 18 | 28 | 30 |
| 第一次数组查找范围 | 3 | 7 | 8 | 13 | 14 | 16 | 18 | 28 | 30 |
| 中间值14，（8<14） | - | - | - | - | 14 | - | - | - | - |
| 第二次数组查找范围 | 3 | 7 | 8 | 13 | 14 | 16 | 18 | 28 | 30 |
| 中间值7，（8>7） | - | 7 | - | - | - | - | - | - | - |
| 第三次数组查找范围 | 3 | 7 | 8 | 13 | 14 | 16 | 18 | 28 | 30 |
| 中间值8，（8==8） | - | - | 8 | - | - | - | - | - | - |
| 两个值相等 | - | - | 找到了 | - | - | - | - | - | - |
3.3、数据查找流程
从索引start=0到索引end=8,要检索的数组范围为：[3, 7, 8, 13, 14, 16, 18, 28, 30]
此时要检索的数组的中间值为：14，索引为：4
目标元素【8】小于中间值【14】,接下来从索引start=0到索引end=3进行检索
从索引start=0到索引end=3,要检索的数组范围为：[3, 7, 8, 13]
此时要检索的数组的中间值为：7，索引为：1
目标元素【8】大于中间值【7】,接下来从索引start=2到索引end=3进行检索
从索引start=2到索引end=3,要检索的数组范围为：[8, 13]
此时要检索的数组的中间值为：8，索引为：2
目标元素【8】等于中间值【8】,找到数据,索引值为：2
递归方式实现二分查找法查询结果：2
四、迭代方式
4.1、代码实现
/**
* 二分查找法
*
* @param arr 要查找的数组（必须采用顺序存储结构，而且表中元素按关键字有序排列）
* @param targetValue 要查找的值
* @return 如果查询到则返回该数据在数组中的索引
* 如果未查到则返回-1
*/
public static int binarySearch(int[] arr, int targetValue) {
//定义最小索引
int startIndex = 0;
//定义最大索引
int endIndex = arr.length - 1;
//循环查找（不要越界）
while (startIndex <= endIndex) {
log.info("从索引start={}到索引end={},要检索的数组范围为：{}", startIndex, endIndex, Arrays.copyOfRange(arr, startIndex, endIndex + 1));
//定义中间值的索引
int midIndex = (startIndex + endIndex) / 2;
//定义中间值
int midValue = arr[midIndex];
log.info("此时要检索的数组的中间值为：{}，索引为：{}", midValue, midIndex);
if (targetValue < midValue) {
//要查找的值小于中间值
endIndex = midIndex - 1;
log.info("目标元素【{}】小于中间值【{}】,接下来从索引start={}到索引end={}进行检索", targetValue, midValue, startIndex, midIndex - 1);
} else if (targetValue > midValue) {
//要查找的值大于中间值
startIndex = midIndex + 1;
log.info("目标元素【{}】大于中间值【{}】,接下来从索引start={}到索引end={}进行检索", targetValue, midValue, midIndex + 1, endIndex);
} else {
//查找到要找的值
log.info("目标元素【{}】等于中间值【{}】,找到数据,索引值为：{}", targetValue, midValue, midIndex);
return midIndex;
}
}
return -1;
}
public static void main(String[] args) {
//注意此数组应该是线性的，递增或者递减（本文是递增）
//如果是递减得修改算法里的条件判断，思路一样
int int[] arr = new int[]{3, 7, 8, 13, 14, 16, 18, 28, 30};
//调用迭代方式的二分查找法
int result = binarySearch(arr, 28);
log.info("迭代方式实现二分查找法查询结果（索引值）：{}", result);
}
4.2、数据流向过程
假设我们在数组中查找 28 这个元素，那么查找的数据流程如下表格：（蓝色的表示要查找的范围）
| 数组索引 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|---|
| 原数组元素（查找8） | 3 | 7 | 8 | 13 | 14 | 16 | 18 | 28 | 30 |
| 第一次数组查找范围 | 3 | 7 | 8 | 13 | 14 | 16 | 18 | 28 | 30 |
| 中间值14，（28>14） | - | - | - | - | 14 | - | - | - | - |
| 第二次数组查找范围 | 3 | 7 | 8 | 13 | 14 | 16 | 18 | 28 | 30 |
| 中间值18，（28>18） | - | - | - | - | - | - | 18 | - | - |
| 第三次数组查找范围 | 3 | 7 | 8 | 13 | 14 | 16 | 18 | 28 | 30 |
| 中间值28，（28==28） | - | - | - | - | - | - | - | 28 | - |
| 两个值相等 | - | - | - | - | - | - | - | 找到了 | - |
4.3、数据查找流程
从索引start=0到索引end=8,要检索的数组范围为：[3, 7, 8, 13, 14, 16, 18, 28, 30]
此时要检索的数组的中间值为：14，索引为：4
目标元素【28】大于中间值【14】,接下来从索引start=5到索引end=8进行检索
从索引start=5到索引end=8,要检索的数组范围为：[16, 18, 28, 30]
此时要检索的数组的中间值为：18，索引为：6
目标元素【28】大于中间值【18】,接下来从索引start=7到索引end=8进行检索
从索引start=7到索引end=8,要检索的数组范围为：[28, 30]
此时要检索的数组的中间值为：28，索引为：7
目标元素【28】等于中间值【28】,找到数据,索引值为：7
迭代方式实现二分查找法查询结果（索引值）：7
结语
可能有些小伙伴不知道，索引 加1或者减1 的原因:
- 关于数组，假设一个数组的长度是 9 ，数组的下标是从 0 开始的，最大的下标就是 8 ，最后一个元素就是 a[8] ，相对长度来说，数组的索引就是 数组长度减1
- 关于中间值比较的索引，因为二分查找中要求顺序存储并且是有序排列，如果是递增的，也就是左边的数据小于中间值，右边的数据大于中间值，中间值的索引是 midIndex ，查找的值比中间值小，则我们只需要比较开始索引到 midIndex-1 这一段数据了，查找的值比中间值小，则我们只需要比较 midIndex+1 到结束索引这一段数据了，如果是递减的，就反过来就行了
多看两边我按个数据流向的图就容易理解了，希望你也能掌握。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
