（二）Java算法：插值查找

一、简介

1.1、特点

  插值查找，有序表的一种查找方式。插值查找是根据查找关键字与查找表中最大最小记录关键字比较后的查找方法。插值查找基于二分查找，将查找点的选择改进为自适应选择，提高查找效率。插值查找中中值的计算公式如下：

二、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>

三、实现

3.1、代码实现

  由于 插值查找法 和 二分查找法 是类似的，只不过在于中值的获取不一样，我这里就只用迭代方法演示了，递归的方式可以查看我的文章：（一）Java算法：二分查找

	/**
     * 插值查找
     *
     * @param arr    要查找的数组（必须采用顺序存储结构，而且表中元素按关键字有序排列）
     * @param targetValue 要查找的值
     * @return 如果查询到则返回该数据在数组中的索引
     *         如果未查到则返回-1
     */
    public static int interpolationSearch(int[] arr, int targetValue) {
        int startIndex = 0;
        //定义最大索引
        int endIndex = arr.length-1;
        //循环查找（不要越界）
        while (startIndex <= endIndex) {
            log.info("从索引startIndex={}到索引end={},要检索的数组范围为：{}", startIndex, endIndex, Arrays.copyOfRange(arr, startIndex, endIndex + 1));
            // 中间索引值 = 开始索引 +(结束索引 - 开始索引)*(目标值 - 开始索引对应的数组值)/(结束索引对应的数组值 - 开始索引对应的数组值)
            int midIndex = startIndex + (endIndex - startIndex) * (targetValue - arr[startIndex]) / (arr[endIndex] - arr[startIndex]);
            //确定中间值
            int midValue = arr[midIndex];
            log.info("此时要检索的数组的中间值为：{}，索引为：{}", midValue, midIndex);
            if (targetValue < midValue) {
                //要查找的值小于中间值
                endIndex = midIndex - 1;
                log.info("目标元素【{}】小于中间值【{}】,接下来从索引startIndex={}到索引end={}进行检索", targetValue, midValue, startIndex, midIndex - 1);
            } else if (targetValue > midValue) {
                //要查找的值大于中间值
                startIndex = midIndex + 1;
                log.info("目标元素【{}】大于中间值【{}】,接下来从索引startIndex={}到索引end={}进行检索", targetValue, midValue, midIndex + 1, endIndex);
            } else {
                //查找到要找的值
                log.info("目标元素【{}】等于中间值【{}】,找到数据,索引值为：{}", targetValue, midValue, midIndex);
                return midIndex;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        //注意此数组应该是线性的，递增或者递减（本文是递增）
        //如果是递减得修改算法里的条件判断，思路一样
        int[] arr = new int[]{3, 7, 8, 13, 14, 16, 18, 28, 30};

        log.info("--------------------------------插值查找(8)------------------------------------");
        int result1 = interpolationSearch(arr, 8);
        log.info("插值查找法查询结果（索引值）：{}", result1);
        log.info("--------------------------------插值查找(28)------------------------------------");
        int result2 = interpolationSearch(arr, 28);
        log.info("插值查找法查询结果（索引值）：{}", result2);
    }

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
中间值7，（8>7）	-	7	-	-	-	-	-	-	-
第二次数组查找范围	3	7	8	13	14	16	18	28	30
中间值8，（8==8）	-	-	8	-	-	-	-	-	-
两个值相等	-	-	找到了	-	-	-	-	-	-

  假设我们在数组中查找 28 ，那么查找的数据流程如下表格：（蓝色的表示要查找的范围）

数组索引	0	1	2	3	4	5	6	7	8
原数组元素（查找28）	3	7	8	13	14	16	18	28	30
第一次数组查找范围	3	7	8	13	14	16	18	28	30
中间值28，（28=28）	-	-	-	-	-	-	-	28	-
两个值相等	-	-	-	-	-	-	-	找到了	-

  中间值的计算通过我上面的公式就好了，就不再一一列举了。

3.3、数据查找流程

--------------------------------插值查找(8)------------------------------------
从索引startIndex=0到索引end=8,要检索的数组范围为：[3, 7, 8, 13, 14, 16, 18, 28, 30]
此时要检索的数组的中间值为：7，索引为：1
目标元素【8】大于中间值【7】,接下来从索引startIndex=2到索引end=8进行检索
从索引startIndex=2到索引end=8,要检索的数组范围为：[8, 13, 14, 16, 18, 28, 30]
此时要检索的数组的中间值为：8，索引为：2
目标元素【8】等于中间值【8】,找到数据,索引值为：2
插值查找法查询结果（索引值）：2
--------------------------------插值查找(28)------------------------------------
从索引startIndex=0到索引end=8,要检索的数组范围为：[3, 7, 8, 13, 14, 16, 18, 28, 30]
此时要检索的数组的中间值为：28，索引为：7
目标元素【28】等于中间值【28】,找到数据,索引值为：7
插值查找法查询结果（索引值）：7

结语

  虽说从结果上看来，好像比我们之前的 二分查找法 效率更高，但是这个也是有前提的，那就是 数据应该是线性均匀的 。如果我们的数据分布不是很均匀，比如是下面这样：

    public static void main(String[] args) {
        //注意此数组应该是线性的，递增或者递减（本文是递增）
        //如果是递减得修改算法里的条件判断，思路一样
        int[] arr = new int[]{3, 7, 8, 13, 14, 16, 18, 28, 199};
        log.info("--------------------------------插值查找(28)------------------------------------");
        int result2 = interpolationSearch(arr, 28);
        log.info("插值查找法查询结果（索引值）：{}", result2);
    }

则运行的结果如下：

--------------------------------插值查找(28)------------------------------------
从索引startIndex=0到索引end=8,要检索的数组范围为：[3, 7, 8, 13, 14, 16, 18, 28, 199]
此时要检索的数组的中间值为：7，索引为：1
目标元素【28】大于中间值【7】,接下来从索引startIndex=2到索引end=8进行检索
从索引startIndex=2到索引end=8,要检索的数组范围为：[8, 13, 14, 16, 18, 28, 199]
此时要检索的数组的中间值为：8，索引为：2
目标元素【28】大于中间值【8】,接下来从索引startIndex=3到索引end=8进行检索
从索引startIndex=3到索引end=8,要检索的数组范围为：[13, 14, 16, 18, 28, 199]
此时要检索的数组的中间值为：13，索引为：3
目标元素【28】大于中间值【13】,接下来从索引startIndex=4到索引end=8进行检索
从索引startIndex=4到索引end=8,要检索的数组范围为：[14, 16, 18, 28, 199]
此时要检索的数组的中间值为：14，索引为：4
目标元素【28】大于中间值【14】,接下来从索引startIndex=5到索引end=8进行检索
从索引startIndex=5到索引end=8,要检索的数组范围为：[16, 18, 28, 199]
此时要检索的数组的中间值为：16，索引为：5
目标元素【28】大于中间值【16】,接下来从索引startIndex=6到索引end=8进行检索
从索引startIndex=6到索引end=8,要检索的数组范围为：[18, 28, 199]
此时要检索的数组的中间值为：18，索引为：6
目标元素【28】大于中间值【18】,接下来从索引startIndex=7到索引end=8进行检索
从索引startIndex=7到索引end=8,要检索的数组范围为：[28, 199]
此时要检索的数组的中间值为：28，索引为：7
目标元素【28】等于中间值【28】,找到数据,索引值为：7
插值查找法查询结果（索引值）：7

  从这里也看到， 数据分布不均匀 的时候， 插值查找法 的效率反而比 二分查找法 的效率更低了