数据结构和算法(第八章查找算法)

---

前言

数据结构和算法-查找算法

---

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

一、常用查找算法

(1)顺序(线性)查找
按照顺序比对，找到我们需要的数据
(2)二分查找/折半查找
(3)插值查找
(4)斐波那契查找(黄金分割查找)

二、线性查找算法

1. seqSearch分析

线性查找是逐一比对，发现有相同值，就返回下标

2.seqSearch代码

//线性查找
    public static int seqSearch(int[] arr,int value){
        //遍历数组，与要查找的数进行比较，相同时返回其索引
        for(int i=0;i<arr.length;i++){
            if(arr[i]==value){
                return i;
            }
        }
        return -1;
    }
```c

3. seqSearch小练

https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof/

三、二分查找算法

1. binarySearch分析

使用二分查找算法的前提是该数组是有序的

2.binarySearch代码

//二分查找
    public static int binarySearch(int[] arr,int left,int right,int findVal){
        //当left>right时，说明递归啦整个数组但是没有找到
        if(left>right){
            return -1;
        }
        int mid=(left+right)/2;
        if(findVal>arr[mid]){
            //要找的值在中间位置的右边，所以向右递归
            return binarySearch(arr,mid+1,right,findVal);
        }else if(findVal<arr[mid]){
            return binarySearch(arr,left,mid-1,findVal);
        }else{
            //找到该值
            return mid;
        }
    }
    /**
     *数组中有多个相同的数值时，将所有数据都找到
     * 思路分析：
     * 1，在找到mid索引值后，不要马上返回
     * 2，向mid索引值的左边扫描，将所有满足相同的元素索引，加入到集合ArrayList
     * 3，向mid索引值的右边扫描，将所有满足相同的元素的索引，加入到集合ArrayList
     * 4，将ArrayList返回
     */
    public static List<Integer> binarySearch2(int[] arr,int left,int right,int findVal){
        //当left>right时，说明递归啦整个数组但是没有找到
        if(left>right){
            return new ArrayList<Integer>();
        }
        int mid=(left+right)/2;
        if(findVal>arr[mid]){
            //要找的值在中间位置的右边，所以向右递归
            return binarySearch2(arr,mid+1,right,findVal);
        }else if(findVal<arr[mid]){
            return binarySearch2(arr,left,mid-1,findVal);
        }else{
            List<Integer> resIndexList=new ArrayList<>();
            //2*左边
            int temp=mid-1;
            while (true){
                if(temp<0||arr[temp]!=findVal){
                    break;
                }
                resIndexList.add(temp);
                temp-=1;//temp左移
            }
            //1中间
            resIndexList.add(mid);
            //3*右边
            temp=mid+1;
            while(true){
                if(temp>arr.length||arr[temp]!=findVal){
                    break;
                }
                resIndexList.add(temp);
                temp+=1;//temp右移
            }

            //找到该值
            return resIndexList;
        }
    }
```c

3. binarySearch小练

https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/

四、插值查找算法

1. insertValueSearch分析

对二分查找的优化，将mid改为–>自适应mid
当数据量较大时,并且数据之间跳跃性不大时(关键字分布比较均匀)，采用插值查找, 速度较快，mid自适应
mid=left+(right-left) * (findVal-arr[left]) / (arr[right]-arr[left])

2.insertValueSearch代码

public static int insertValueSearch(int[] arr,int left,int right,int findVal){
        if(left>right||findVal<arr[0]||findVal>arr[arr.length-1]){
            return -1;
        }
        int mid=left+(findVal-arr[left])*(right-left)/(arr[right]-arr[left]);
        if(findVal>arr[mid]){
            //要找的值在arr[mid]的右边，递归向右查找
            return insertValueSearch(arr,mid+1,right,findVal);
        }else if(findVal<arr[mid]){
            //要找的值在arr[mid]的做百年
            return insertValueSearch(arr,left,mid-1,findVal);
        }else{
            return mid;
        }
    }
```c

3. insertValueSearch小练(二分查找更简单)

https://leetcode-cn.com/problems/binary-search/

五、斐波那契查找算法

1. FibonacciSearch分析

黄金分割:是指将整体一分为二，较大部分与整体部分的比值等于较小部分与较大部分的比值，其比值约为0.618
FibonacciSearch:借助一个斐波那契数列来配合我们这个数组来找黄金分割点
low,high相当于指针

2.FibonacciSearch代码

    //因为后面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];
        }
        return f;
    }

    /**
     * 斐波那契查找算法,使用非递归方式
     * 1，temp = {1,8, 10, 89, 1000, 1234, 0, 0} => {1,8, 10, 89, 1000, 1234, 1234, 1234}
     * 2，使用 while 来循环处理，找到我们的数 key
     */
    public static int fibSearch(int[] arr, int key) {
        int low = 0;
        int high = arr.length - 1;
        int k = 0;//mid=low+F(k-1)-1
        int mid = 0;
        int[] f = fib();//获取斐波那契数列
        //获取到斐波那契分割数值的下标
        while (high > f[k] - 1) {
            k++;
        }
        //由于f[k]的值可能大于arr的长度，所以要将数组扩容
        int[] temp = Arrays.copyOf(arr, f[k]);
        //将数组后面扩容的数置为high
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = arr[high];
        }
        //使用while来循环处理，找到我们的数key
        while (low <= high) {
            mid = low + f[k] - 1;
            /**
             * 切分以后继续找黄金分割点： F[k]=F[k-1]+F[k-2];
             *     黄金分割点前面有k-1个元素，后面有k-2个元素
             *     黄金分割点为k
             *         如果该值在k前面，就套用黄金分割F[k-1]=F[k-1-1]+F[k-2-1] k--;
             *         如果该值在k后面，就F[k-2]=F[k-1-2]+F[k-2-2] k-=2;
             */
            if (key < temp[mid]) {//说明应该继续向数组左边查找
                high = mid - 1;
                k--;
            } else if (key > temp[mid]) {
                low = mid + 1;
                k -= 2;
            } else {
                //找到
                if (mid < high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }

```c

3. FibonacciSearch小练

---

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。