数据结构与算法（六）（查找算法）

线性查找

1.代码实现

package search;

public class SeqSearch {
    public static void main(String[] args) {
        int[] arr = {101,100,99,33};
        System.out.println(seqSearch(arr,110));
    }
    public static int seqSearch(int[] arr,int val){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==val){
                return i;
            }
        }
        return -1;
    }
}

二分查找

1.条件：必须是一个有序的数组
2.思路分析：先找到该数组最中间的元素arr[（left+right）/2]，将要查找的数字与中间数字作比较，如果大与中间数字，那么就在中间数字的右侧重复上述过程,左侧同理，递归该过程
3.代码实现

package search;

import java.util.ArrayList;

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1,2,5,33,38,38,38};
        System.out.println(binarySearch(arr,0,6,38));
    }

    public static ArrayList<Integer> binarySearch(int[] arr, int left, int right, int val){
        int mid = (left+right)/2;
        int midVal = arr[mid];
        if(left>right){
            return new ArrayList<Integer>();
        }
        if(val<midVal){
            //此处为递归
            return binarySearch(arr,left,mid-1,val);
        }else if(val>midVal){
            //此处为递归
            return binarySearch(arr,mid+1,right,val);
        }else{
            //此处为优化，取出相同数字的下标
            ArrayList<Integer> arrayList = new ArrayList<>();
            arrayList.add(mid);
            int temp = mid-1;
            while(true){
                if(temp<0 || arr[temp] != val){
                    break;
                }
                arrayList.add(temp);
                temp--;
            }
            temp = mid+1;
            while(true){
                if(temp>arr.length-1 || arr[temp] != val){
                    break;
                }
                arrayList.add(temp);
                temp++;
            }
            return arrayList;
        }
    }
}

插值查找

1.算法简介：总体来说与二分查找区别不大，只是在mid的取值上有所不同，二分查找中mid值是（left+right）/2，而插值查找中的mid：

其中low就是left，high就是right，key就是要查找的数字，使用插值查找可以减少递归次数，提高效率
2.算法使用：适用于数据量较大，数字分布比较均匀
3.代码实现

package search;

import java.util.Arrays;

public class InsertSearch {
    public static void main(String[] args) {
        int[] arr = new int[100];
        for(int i=0;i<arr.length;i++){
            arr[i] = i;
        }
        System.out.println(insertSearch(arr,0,99,6));
    }

    public static int insertSearch(int[] arr,int left,int right,int val){
        //val<arr[0] ，val>arr[arr.length-1]这两个条件必须有，避免midVal出现数组越界
        if(left>right || val<arr[0] || val>arr[arr.length-1]){
            return -1;
        }
        //此处为插入查找的的核心
        int mid = left+(right-left)*((val-arr[left])/(arr[right]-arr[left]));
        int midVal = arr[mid];
        if(val>midVal){
            return insertSearch(arr,mid+1,right,val);
        }else if(val<midVal){
            return insertSearch(arr,left,mid-1,val);
        }else{
            return mid;
        }
    }
}

斐波那契查找

1.算法分析：斐波那契查找，又名黄金分割查找，f[k] = f[k-1] +f[k-2]这是斐波那契数列的性质，
我们可以得到：全部元素（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，但是我们提供的数组不一定长度是f[k]-1，那么我们就增加数组的长度到f[k]-1

2.代码实现

package search;

import java.util.Arrays;

public class FinbonacciSearch {
    public static int max = 20;
    public static void main(String[] args) {
        int[] arr = {1,8,10,89,1000,1234};
        System.out.println(fibSearch(arr,8));
    }
    //创建斐波那契数列
    public static int[] fib(){
        int[] f = new int[max];
        f[0] = 1;
        f[1] = 1;
        for(int i=2;i<f.length;i++){
            f[i] = f[i-1] + f[i-2];
        }
        return f;
    }

    public static int fibSearch(int[] a,int key){
        int low = 0;
        int high = a.length-1;
        int k=0;
        int mid = 0;
        int[] f = fib();
        //寻找合适的k值，为啦创造符合条件的数组
        while(high>f[k]-1){
            k++;
        }
        //创建辅助数组让a数组达到f[k]的规模
        int[] temp = Arrays.copyOf(a,f[k]);
        //填充辅助数组
        for(int i=high+1;i<temp.length;i++){
            temp[i] = a[high];
        }

        while (low <= high){
            //获取mid值
            mid = low +f[k-1]-1;
            if(key<temp[mid]){
                high = mid-1;
                //首先，全部元素（f[k]） = 前面的元素(f[k-1]) + 后面的元素(f[k-2])
                //此时需要向前找，所以f[k-1] = f[k-2] +f[k-3]总体-1，故k--
                k--;
            }else if(key>temp[mid]){
                low = mid+1;
                //首先，全部元素（f[k]） = 前面的元素(f[k-1]) + 后面的元素(f[k-2)
                //此时需要向后找，所以f[k-2] = f[k-3] +f[k-4]总体-2，故k-=2
                k-=2;
            }else {
                if(mid<=high){
                    return mid;
                }else{
                    return high;
                }
            }
        }
        return -1;
    }
}