(一)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 ,那么查找的数据流程如下表格:(蓝色的表示要查找的范围)

数组索引012345678
原数组元素(查找8)378131416182830
第一次数组查找范围378131416182830
中间值14(8<14)----14----
第二次数组查找范围378131416182830
中间值7(8>7)-7-------
第三次数组查找范围378131416182830
中间值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 这个元素,那么查找的数据流程如下表格:(蓝色的表示要查找的范围)

数组索引012345678
原数组元素(查找8)378131416182830
第一次数组查找范围378131416182830
中间值14(28>14)----14----
第二次数组查找范围378131416182830
中间值18(28>18)------18--
第三次数组查找范围378131416182830
中间值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 到结束索引这一段数据了,如果是递减的,就反过来就行了

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值