07_ 查找算法

bfjStart
104 阅读4分钟
  • 查找算法的介绍
  • 线性查找算法
  • 二分查找/折半查找
  • 插值查找
  • 斐波那契查找

1. 查找算法的介绍

  • 我们常用的查找有四种

    1） 顺序（线性）查找

    2） 二分查找/折半查找

    3）插值查找

    4）斐波那契查找

2. 线性查找算法

  • 基本思想：对一个数列，按顺序查找，如果找到了，就返回对应的下标值

  • 代码实现

public class SeqSearch {
    public static void main(String[] args) {
        int arr[] = {1,9,11,-1,34,89}; //无序的数组
        int index = seqSearch(arr,11);
        if(index == -1){
            System.out.println("没有查找到");
        }else{
            System.out.println("找到了，下标位："+index);
        }
    }

    /**
     * 实现的线性查找是找到一个满足条件的值，就返回
     * @param arr
     * @param value
     * @return
     */
    public static int seqSearch(int[] arr,int value){
        //线性查找是逐一比对，发现有相同值，就返回下标
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == value){
                return i;
            }
        }
        return -1;
    }
}

3. 二分查找算法

3.1 思路分析

① 首先确定该数组的中间的下标 mid=(left/right)/2

② 让需要查找的数 findVal 和 arr[mid] 比较

​ 2.1 findVal > arr[mid] ,说明你要查找的数在 mid 的右边，因此需要递归的向右查找

​ 2.2 findVal < arr[mid], 说明你要查找的数在 mid 的左边，因此需要递归的向左查找

​ 2.3 findVal = arr[mid]，说明找到，就返回

  • 什么时候需要结束递归

① 找到就结束递归

② 递归完整个数组，仍然没有找到 findVal ,也需要结束递归，当 left > right 就需要退出

3.2 代码实现

  • 递归实现
//注意：使用二分查找的前提是，该数组是有序的
public class BinarySearch {
    public static void main(String[] args) {
        int arr[] = {1,8,10,89,1000,1234}; //有序的数组
//        int resIndex = binarySearch(arr,0,arr.length-1,1000);
//        System.out.println("resIndex="+resIndex);
        //第二种测试
        List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1000);
        System.out.println("resIndexList"+resIndexList);
    }

    //二分查找法
    /**
     * 二分查找法(只能找到一个结果)
     * @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;
        }
    }

    //将有序数组中的所有数值都查找到
    //思路：
    //1. 在找到 mid 索引值，不要马上返回
    //2. 向 mid 索引的左边扫描，将所有满足1000 的元素的下标，加入到集合ArrayList
    //3. 向 mid 索引的右边扫描， 将所有满足1000 的元素的下标，加入到集合 ArrayList
    //4. 返回ArrayList
    public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal){
        if(left > right){
            return new ArrayList<>();
        }
        int mid = (left + right) / 2;
        int midVal = arr[mid];

        if(findVal > midVal){ //向右递归
            return binarySearch2(arr,mid+1,right,findVal);
        }else if(findVal < midVal){ //向左递归
            return binarySearch2(arr,left,mid - 1,findVal);
        }else { //找到了
            List<Integer> resIndexList = new ArrayList<>();
            //向 mid 索引的左边扫描，将所有满足1000 的元素的下标，加入到集合ArrayList
            int temp = mid - 1;
            while (true){
                if(temp < 0 || arr[temp] != findVal){
                    break;
                }
                //否则，就把temp放入 resIndexList
                resIndexList.add(temp);
                temp -= 1; //将temp 左移
            }
            resIndexList.add(mid);
            //向 mid 索引的右边扫描， 将所有满足1000 的元素的下标，加入到集合 ArrayList
            temp = mid + 1;
            while (true){
                if(temp > arr.length-1 || arr[temp] != findVal){
                    break;
                }
                //否则，就把temp放入 resIndexList
                resIndexList.add(temp);
                temp += 1; //将temp 左移
            }
            return resIndexList;
        }
    }
}
  • 非递归实现
public class BinarySearchNoRecur {
    public static void main(String[] args) {
        //测试
        int[] arr = {1,3,8,10,11,67,100};
        int index = binarySearch(arr,9);
        System.out.println("index=" + index); //
    }

    /**
     *  二分查找的非递归实现
     * @param arr 待查找的数组，arr是升序排序
     * @param target 需要查找的数
     * @return 返回对应下标，-1表示没有找到
     */
    public static int binarySearch(int[] arr,int target){
        int left = 0;
        int right = arr.length - 1;
        while(left <= right){ //说明可以继续查找
            int mid = (left + right) / 2;
            if(arr[mid] == target){
                return mid;
            }else if(arr[mid] > target){
                right = mid - 1; //需要左移查找
            }else if(arr[mid] < target){
                left = mid + 1; //需要向右边查找
            }
        }
        return -1;
    }

}

4. 插值查找算法

  • 原理介绍：类似于二分查找，不同的插值查找每次从自适应 mid 开始查找,其它与二分查找的查找方法类似。
  • int mid = low + (high-low)*(key-arr[low])/(arr[high]-arr[low])

image-20220325222148612

  • 对应的代码为：

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

  • 代码实现

public class InsertvalueSearch {
    public static void main(String[] args) {
        int[] arr = new int[100];
        for (int i = 0; i < 100 ; i++) {
            arr[i] = i + 1;
        }
//        System.out.println(Arrays.toString(arr));
        int index = insertValueSearch(arr,0,arr.length-1,100);
        System.out.println("index = " + index);
    }

    //编写插值查找算法，
    //说明：插值查找算法，也要求数组是有序的
    /**
     *
     * @param arr 数组
     * @param left 左边的索引
     * @param right 右边的索引
     * @param findVal 要查找的值
     * @return 如果找到就返回对应的下标，如果没有找到，返回-1
     */
    public static int insertValueSearch(int[] arr,int left,int right,int findVal){
        System.out.println("查找次数");

        //注意：findVal < arr[0] || findVal > arr[arr.length-1] 必须要，否则得到的mid 可能越界
        if(left > right || findVal < arr[0] || findVal > arr[arr.length-1]){ //大于最大的，小于最小的
            return -1;
        }
        //求出mid，自适应的写法，自身加入了计算
        int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
        int mindVal = arr[mid];
        if(findVal > mindVal){ //说明应该向右递归查找
            return insertValueSearch(arr,mid+1,right,findVal);
        }else if(findVal < mindVal){ //说明应该向左递归查找
            return insertValueSearch(arr,left,mid-1,findVal);
        }else{
            return mid;
        }
    }
}
  • 注意事项
    • 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快
    • 关键字分布不均匀的情况，不一定比折半查找好

5. 斐波那契（黄金）查找算法

5.1 基本介绍

  • 黄金分割点：把一条线段分成两部分，使其中一部分与全长之比等于另外一部分与这部分之比。取前三位的数字的近似值为0.618
  • 斐波那契数列{1,1,2,3,5,8,13,21,34,55},发现斐波那契数列的两个相邻数的比例，无限接近 黄金分割值 0.618

5.2 斐波那契(黄金分割法)原理

  • 改变中间结点（mid)的位置，mid不再是中间或插值得到，而是黄金分割点附近，即 mid=low+F(k-1)-1

image-20220404104622676

  • 对于斐波那契数列 F[k]=F[k-1]+F[k-2]的性质，可以得到 (F[k]-1) = (F[k-1]-1) + (F[k-2]-1) + 1。说明：只要顺序表的长度为 F[k]-1,则可以将该表分成长度为 F[k-1]-1 和 F[k-2]-1 的两段，如上图，从中间的位置为 mid=low+F(k-1)-1

5.3 思路分析

① 将要查找数组的长度 high=数组.length-1与 斐波那契数列中的数f[k]-1 比较

​ 当 high>f[k]-1时,k++

​ 当 high<=f[k]-1时，结束循环

② 将数组扩充f[k]长度，得到数组temp

③ 将数组扩充后的0，填充为数组的最后一个数a[high]

④ 设置low=0,当 low <= high 循环内 ，设置mid=low+f[k-1]-1：

​ 如果我们要找的数小于临时数组的mid所在位置的值时：key< temp[mid]，将 high=mid-1,k--;

​ 如果我们要找的数大于临时数组的mid所在位置的 值时：key>temp[mid] ，将low = mid + 1,k-=2;

​ 如果找到了key=temp[mid],并且mid<=high时，返回位置的值mid,否则返回high

5.4 代码实现

import java.util.Arrays;

/**
 * @create 2022-02-28 17:24
 */
public class fibonacciSearch {
    public static int maxSize = 20;
    public static void main(String[] args) {
        int[] arr = {1,8,10,89,1000,1234};
        System.out.println(fibSearch(arr,89));
    }
    //因为后面我们 mid = low + F(k-1)-1,需要使用到斐波那契数列，
    // 因此我们需要先获取一个斐波那契数列
    //非递归方法得到一个斐波那契数列
    public static int[] fib(){
        int[] f = new int[maxSize];
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            f[i] = f[i-1] + f[i-2];
        }
        System.out.println(Arrays.toString(f)); //[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
        return f;
    }

    //编写斐波那契数列查找算法
    //使用非递归的方式编写
    /**
     *
     * @param a 数组
     * @param key 我们需要查找的关键码（值）
     * @return 返回对应的下标，如果没有 -1
     */
    public static int fibSearch(int[] a,int key){
        int low = 0;
        int high = a.length - 1;
        int k = 0; //表示斐波那契分割数值的下标
        int mid = 0; //存放mid值
        int f[] = fib(); //获取到斐波那契数列
        //获取到斐波那契分割数值的下标
        while(high > f[k] - 1){
            k++;
        }
        //因为 f[k] 值可能大于 a 的长度，因此我们需要使用Arrays类，构造一个新的数组，并指向a
        //不足的部分会使用0填充
        int[] temp = Arrays.copyOf(a,f[k]); //将a扩充到 f[k]（是个数） 长度
        System.out.println(Arrays.toString(temp)); // [1, 8, 10, 89, 1000, 1234, 0, 0]
        //需要使用a数组的最后数填充 temp
        //举例：1,8,10,89,1000,1234,0,0 -> 1,8,10,89,1000,1234,1234,1234
        for(int i = high + 1; i < temp.length;i++){
            temp[i] = a[high];
        }
        //使用while来循环处理，找到我们的数 key
        while(low <= high){
            mid = low + f[k-1] - 1;
            if(key < temp[mid]){ //应该继续向数组的前面（左边）递归查找
                high = mid - 1;
                //为什么是k--,
                //说明
                //1. 全部元素 = 前面的元素 + 后边元素
                //2. f[k] = f[k-1] + f[k-2]
                //因为 前面有 f[k-1] 个元素，所以可以继续拆分 f[k-1] = f[k-2] + f[k-3]
                //即在 f[k-1] 的前面继续查找 k--;
                //即下次循环 mid = f[k-1-1]-1
                k--;
            }else if(key > temp[mid]){ //继续向数组的右边查找
                low  = mid + 1;
                //为什么是k-=2
                //1. 全部元素 = 前面的元素 + 后边元素
                //2. f[k] = f[k-1] + f[k-2]
                //3. 因为后面有 f[k-2],所以可以继续拆分 f[k-2] = f[k-3] + f[k-4]
                //4. 即f[k-2] 的前面进行查找 k-=2;
                //5. 即下次循环 mid = f[k-1-2] - 1
                k -= 2;
            }else{ //找到
                //需要确定，返回的是那个下标
                if(mid <= high){
                    return mid;
                }else{
                    return high;
                }
            }
        }
        return  -1;
    }
}
avatar
文章
阅读
粉丝