（一）Java算法：二分查找

一、简介

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 到结束索引这一段数据了，如果是递减的，就反过来就行了

  多看两边我按个数据流向的图就容易理解了，希望你也能掌握。