数据结构与算法 查找算法

二分查找

请对一个有序数组进行二分查找 {1,8, 10, 89, 1000, 1234} ，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示 " 没有这个数 " 。

 

/**
     *
     * @param arr 数组
     * @param left 左边的索引
     * @param right 右边的索引
     * @param findVal 要查找的值
     * @return 找到就返回下标 没找到返回-1
     */
    public static int binarySearch(int[] arr,int left,int right,int findVal){
        if (left > right){
            return -1;
        }
        int mid = (left+right)/2;
        int midVal = arr[mid];

        if(findVal > midVal){
            //要找的数比选定的中间值大，向右递归
            return binarySearch(arr,mid+1,right,findVal);
        }else if (findVal < midVal){
            //要找的数比选定的中间值小，向左递归
            return binarySearch(arr,left,mid-1,findVal);
        }else {
            return mid;
        }
    }

思考：

        如果一个有序数组中有相同的数值时，如果将相同数值的下标也返回呢

        在找到数值后不要马上返回，向mid索引值的左边扫描，将所有满足findVal的元素下标加入到一个集合中。再向mid的右边扫描，将满足findVal的元素下标放到集合里，再将集合返回。

 /**
     * @param arr     数组
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 要查找的值
     * @return 找到就返回下标 没找到返回-1
     */
    public static ArrayList<Integer> binarySearchPlus(int[] arr, int left, int right, int findVal) {
        if (left > right) {
            return new ArrayList<Integer>();
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];

        if (findVal > midVal) {
            //要找的数比选定的中间值大，向右递归
            return binarySearchPlus(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {
            //要找的数比选定的中间值小，向左递归
            return binarySearchPlus(arr, left, mid - 1, findVal);
        } else {
            /**
             * 在找到数值后不要马上返回，向mid索引值的左边扫描，将所有满足findVal的元素下标加入到一个集合中。
             * 再向mid的右边扫描，将满足findVal的元素下标放到集合里，再将集合返回。
             */
            ArrayList<Integer> list = new ArrayList<Integer>();
            //找左边
            int temp = mid - 1;
            while (temp >= 0 && arr[temp] == findVal) {
                list.add(temp--);//加入list后temp左移
            }
            list.add(mid); //把中间的放进去
            temp = mid + 1;
            while (temp < arr.length-1 && arr[temp] == findVal) { //扫描右边
                list.add(temp++);//加入list后temp右移
            }
            return list;
        }
    }

插值查找算法

插值查找算法

1) 插值查找原理介绍 :

插值查找算法类似于二分查找，不同的是插值查找每次从自适应 mid 处开始查找。

2) 将折半查找中的求 mid 索引的公式 , low 表示左边索引 left, high 表示右边索引 right.

key 就是前面我们讲的 findVal

3) int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]) ;/* 插值索引 */

对应前面的代码公式：

int mid = left + (right – left) * (findVal – arr[left]) / (arr[right] – arr[left])

        对于序列{5,8,34,55,66}，如果想要查找‘5’这个元素，按照原先二分查找的思路，在1/2的所占比的基础上分裂，那么序列要分裂（查找）多少次呢？很明显需要2次。那么，假设我们取元素‘8’为中间值，还是查找‘5’这个元素。可以看到仅仅只需要一次比较就确定了‘5’的位置，并且此时‘5’元素的所占比为：1/5，另一部分则为3/5（去除掉了中间值）。可以看到，中间值的选取能够决定查找元素的效率，而中间值的选择跟我上面所说的“所占比”密切相关。（这里的“所占比”是我在个人理解基础上提出来的，目的是方便理解与讲述，不是规定的说法）。
————————————————
版权声明：本文为CSDN博主「萌新也渴望大佬」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45642253/article/details/106819700

/**
     *
     * @param arr 查找数组
     * @param left 起始下标
     * @param right 末尾下标
     * @param value 查找的值
     * @return
     */
    public static int insertValueSearch(int[] arr,int left,int right,int value){
        //递归结束
        //没有找到
        //重点：这里value < arr[0] || value > arr[arr.length - 1]不能省
        //原因：由于需要查找的元素涉及到了求中值的算法运算，根据算法公式可知随着value的增大，mid也随之增大
        //如果如果value过于大时，mid可能越界
        if (left > right || value < arr[0] || value > arr[arr.length - 1]){
            return -1;
        }
        //改变过后求中间下标的算法
        int mid = left +(right - left) * (value - arr[left]) / (arr[right] - arr[left]);
        int midValue = arr[mid];
        if (value > midValue){//右递归
            return insertValueSearch(arr,mid + 1,right,value);
        }else if (value > midValue){//左递归
            return insertValueSearch(arr,left,mid - 1,value);
        }else {//找到了
            return mid;
        }
    }