常见查找算法的介绍及实现

常见的查找算法：

1. 顺序(线性)查找
2. 二分查找/折半查找
3. 插值查找
4. 斐波那契查找

思路分析：

①.顺序（线性）查找 ：

1. 把数组从头到尾遍历，找到就返回数组下标。

②.二分查找（折半查找） ：前提是有序序列

1. 找到该数组的中间的下标
   1）中间值下标： mid = (left+right) / 2;
   2）中间值：midVal = arr[mid];

2. 将需要查找的值和中间值比较

   1） 如果要查找的值小于中间值，证明要查找的在中间值的左边，因此需要递归的向左查找
   2） 反之向右递归查找
   3 ）如果要查找的值等于中间值，证明找到了，就返回该数组下标

3. 给递归设置出口，即：左侧下标 > 右侧下标，详细看下方代码

 ③.插值查找 ：前提是有序序列

1. 插值查找算法类似于二分查找，不同的是插值查找每次从自适应 mid 处开始查找，简单来说就是把求中间值下标的公式修改了一下

2. 具体公式：
   1）二分查找：mid = (left+right) / 2;
   2）插值查找：mid = (right – left) * (findVal – arr[left]) / (arr[right] – arr[left])；

3. 说明：代码和折半查找一模一样，唯独mid的计算方式发生改变。这样的好处在于，对表长较长，且关键字分分布比较均匀，插值查找算法的平均性能要比折半查找要好的多。但是如果表中 关键字分布极端不均匀 那么插值查找还不如折半查找呢。

 ④.斐波那契(黄金分割法)查找算法

1. 黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是 0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意向不大的效果。
2. 斐波那契数列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现斐波那契数列的两个相邻数 的比例，无限接近 黄金分割值0.618
3. 斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid 不再是中间或插值得到，而是位于黄金分割点附近，即 mid=low+F(k-1)-1（F 代表斐波那契数列），如下图所示：
4. 对 F(k-1)-1 的理解：
   1）由斐波那契数列 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
   2）类似的，每一子段也可以用相同的方式分割
   3）但顺序表长度 n 不一定刚好等于 F[k]-1，所以需要将原来的顺序表长度 n 增加至 F[k]-1。这里的 k 值只要能使得 F[k]-1 恰好大于或等于 n 即可，由以下代码得到,顺序表长度增加后，新增的位置（从 n+1 到 F[k]-1 位置），都赋为 n 位置的值即可。

代码实现：

package com.sai;

import java.util.Arrays;
import java.util.Collections;

/**
 * @Author sai
 * @Description 常见的四种查找算法
 * @Time 2020-07-23 15:57
 */
public class Serrch {
    public static void main(String[] args) {

        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};

        int val = 9 ;
        int res1 = sequenceFind(arr,val);  //顺序查找（线性查找）
        int res2 = binarySearch(arr, 0, arr.length - 1, val);  //二分查找
        int res3 = insertValueSearch(arr,0,arr.length-1,val);  //插值查找
        int res4 = fibonacciSearch(arr,val);  //斐波那契查找

        System.out.println("顺序查找："+res1);
        System.out.println("二分查找："+res2);
        System.out.println("插值查找："+res3);
        System.out.println("斐波那契："+res4);

    }

    /**
     * 1.顺序查找（线性查找）
     * @param arr  数组
     * @param value  要查找的数
     * @return
     */
    public static int sequenceFind(int[] arr,int value){
        for(int i=0;i<arr.length;i++){
            if(arr[i] == value){
                return i;
            }
        }
        return -1;
    }

    /**
     * 2.二分查找
     * @param arr  数组
     * @param left  左侧下标
     * @param right  右侧下标
     * @param findVal  待查找的值
     * @return  找到的值的下标
     */
    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, left, mid - 1, findVal);  //向左递归，继续查找
        } else if (findVal > midVal) {
            return binarySearch(arr, mid + 1, right, findVal);   //向右递归，继续查找
        } else {
            return mid;   //找到了，返回下标
        }

    }

    /**
     * 3.插值查找
     * @param arr  数组
     * @param left  左边索引
     * @param right  右边索引
     * @param findVal  要查找的值
     * @return  找到返回下标索引，没有找到返回 -1
     */
    public static int insertValueSearch(int[] arr,int left,int right,int findVal){

        if(left > right || findVal > arr[right] || findVal < arr[left]){  //没有找到
            return -1;
        }

        //  插值查找的公式
        int mid = left + (right-left) * (findVal-arr[left]) / (arr[right]-arr[left]) ;
        int midVal = arr[mid];

        if(findVal < midVal){
            return insertValueSearch(arr, left, mid-1, findVal);  //向左递归，继续查找
        }else if(findVal > midVal){
            return insertValueSearch(arr, mid+1, right, findVal);  //向右递归，继续查找
        }else {
            return mid;  //找到，直接返回下标索引
        }

    }

    /**
     * 4.斐波那契查找
     * @param arr  数组
     * @param key  要查找的值
     * @return  找到，返回下标  未找到，返回-1
     */
    public static int fibonacciSearch(int[] arr,int key){

        int low = 0;
        int high = arr.length-1;
        int k = 0;  //表示斐波那契分割数值的下标
        int mid = 0;  //存放mid值
        int f[] = f();  //获取斐波那契数组

        while (high > f[k]-1){  //获取到斐波那契分割数值的下标
            k++;
        }

        int[] temp = Arrays.copyOf(arr,f[k]);  //扩容并拷贝数组到一个临时数组
        for (int i=high+1;i<temp.length;i++){  //填充为0的部分
            temp[i] = arr[high];
        }

        //查找key
        while (low <= high){
            mid = low + f[k-1] - 1;
            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;  //没有找到
    }

    //获取斐波那契数组
    public static int[] f(){
        int[] f = new int[20];
        f[0] = 1;
        f[1] = 1;
        for(int i=2;i<f.length;i++){
            f[i] = f[i-1] + f[i-2];
        }
        return f;
    }
}