查找算法合集

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

目录

文章目录

常用的查找算法

一、二分查找法

二、插值查找法

三、斐波那契查找法

---

---

常用的查找算法

二分查找法 ，插值查找法，斐波那契查找法

各个算法都是按照方法设定的标准点 进行分割

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、二分查找法

思路：将数组对半分割 判断我们需要查找的值在分割点的左边还是右边，是右边就对右变的数组进行分割在进行判断，反之左边。如果我们要找的值，等于mid下标值就返回该下标

    public static int binarySearch(int[]arr,int left,int right,int findVal){
        if (left> right){
            return -1;
        }
        int mid=(left+right)/2;
        if (findVal==arr[mid]){
            return mid;
        }else if (findVal>arr[mid]){
            return binarySearch(arr,mid+1,right,findVal);
        } else{
            return binarySearch(arr,left,mid-1,findVal);
        }

    }

二、插值查找法

思路：以：left+(right-left)*(findValue-arr[left])/(arr[right]-arr[left] 作为分割点

    public static int InserValue(int [] arr,int left,int right,int findValue){
        System.out.println("1");
        if (left>right||findValue<arr[0]||findValue>arr[arr.length-1]){
            return -1;
        }
        int mid=left+(right-left)*(findValue-arr[left])/(arr[right]-arr[left]);
        if (findValue>arr[mid]){
            return InserValue(arr,mid+1,right,findValue);
        }else if (findValue<arr[mid]){
            return InserValue(arr,left,mid-1,findValue);
        }else{
            return mid;
        }
    }

三、斐波那契查找法

1.先创建一个斐波那契数组

2.循环判断找到不小于 需要查找数组的 斐波那契数组中的最小下标

while (high>f[k]-1){
    k++;
}

3.将原要查找的数组填充到一个斐波那契数组[k] 大小的数组中，将多余默认为0的位置用 原数组下标的最后一个值填充

4.当左下标不大于右下标识循环执行

5.分割点(mid)=low+f[k-1]-1;

6.如果分割点的值大于我们要找的值， 就向分割点左边继续分割

7.如果小于就向分割点的右边继续分割

8.否则相同 就返回右边值和左边值小的下标值

 //因为后面mid=low+F(k-1)-1,需要使用斐波那契数列，因此我们需要先获取到一个斐波那契数列
    public static int [] fib(){
        int [] fb=new int[maxSize];
        fb[0]=1;
        fb[1]=1;
        for (int i = 2; i <maxSize ; i++) {
            fb[i]=fb[i-1]+fb[i-2];
        }
        return fb;
    }
    //编写斐波那契查找算法
    //
    public static int fibonacci(int[] arr,int key){
        int low=0;
        int high= arr.length-1;
        int k=0;//表示斐波那契分割数值的下标
        int mid=0;//存放mid值
        int [] f=fib();//获取斐波那契数列
        //获取斐波那契分割数值的下标
        while (high>f[k]-1){
            k++;
        }
        //因为f[k]对应的值可能大于数组的长度high 因此需要Arrays类来构造一个新的数组并指向arr[];
        //不足的部分用0补充
        int[]temp= Arrays.copyOf(arr,f[k]);
        //用arr数组的最后一个元素填充temp数组
        for (int i = high+1; i <f[k] ; i++) {
            temp[i]=arr[high];
        }
        //只要这个条件满足就可以一直找
        while (low<=high){
            System.out.println("1");
            mid=low+f[k-1]-1;
            if (key<temp[mid]){//满足表示继续想左查找分割
                high=mid-1;
                //k--的原因
                // 1.temp元素=前面元素+后面元素
                // 2.f[k]=f[k-1]+f[k-2];
                //因为 前面还有f[k-1]元素 继续拆分 就是还有f[k-1]=f[k-2]+f[k-3]个元素
                //即就是在f[k-1]的前面继续查找 即下次寻找时mid=low+f[k-1-1]-1;
                k--;
            }else if (key>temp[mid]){
                low=mid+1;
                //为什么是k-2
                // 1.temp元素=前面元素+后面元素
                // 2.f[k]=f[k-1]+f[k-2];
                // 3.因为我们后面有f[k-2]个元素 所以可以继续拆分 就是f[k2]=f[k-3]+f[k]-4;
                k-=2;
            }else {//确定
                //需要确定返回的是哪个下标 返回小的下标值
                if (mid<=high){
                    return mid;
                }else {
                    return high;
                }

            }



        }
        return -1;
    }