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

二分法查找：

mid=1/2

//考虑只有一个值符合查找要求
    public static int binarySearch(int arr[],int left,int right,int finalVal){
        int mid=(left+right)/2;
        if (left>right)
            return -1;
        if (finalVal<arr[mid]){
            return binarySearch(arr,left,mid-1,finalVal);
        }
        else if (finalVal>arr[mid])
            return binarySearch(arr,mid+1,right,finalVal);
        else
            return mid;
    }
    //数组中符合条件的值不止一个
    public static ArrayList binarySearch2(int arr[], int left, int right, int finalVal){
        int mid=(left+right)/2;
        if (left>right)
            return new ArrayList();
        if (finalVal<arr[mid]){
            return binarySearch2(arr,left,mid-1,finalVal);
        }
        else if (finalVal>arr[mid])
            return binarySearch2(arr,mid+1,right,finalVal);
        else{
            ArrayList list=new ArrayList();
            //继续向左扫描
            int temp=mid-1;
            while (true){
                if (temp<0||arr[temp]!=finalVal)
                    break;
                else {
                    list.add(temp);
                    temp--;
                }
            }
            list.add(mid);//注意在中间加入mid，使返回的下标有序
            //向右扫描
            temp=mid+1;
            while (true){
                if (temp>arr.length-1||arr[temp]!=finalVal)
                    break;
                else{
                    list.add(temp);
                    temp++;
                }
            }
            return list;
        }
    }

插值查找：

对于数据量较大，关键字分布比较均匀的查找表来说，插值查找速度较快；若关键字分布不均匀，插值查找不一定比折半查找好

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

//对于数据量较大，关键字分布比较均匀的查找表来说，插值查找速度较快；若关键字分布不均匀，插值查找不一定比折半查找好
    public static int insertValueSearch(int arr[], int left, int right, int finalVal){
        if (left>right||finalVal<arr[left]||finalVal>arr[right]) {//保证mid不会超过数组下标
            System.out.println("cant find");
            return -1;
        }
        int mid=left+(right-left)*(finalVal-arr[left])/(arr[right]-arr[left]);
        if (finalVal<arr[mid]){
            return insertValueSearch(arr,left,mid-1,finalVal);
        }
        else if (finalVal>arr[mid])
            return insertValueSearch(arr,mid+1,right,finalVal);
        else
            return mid;
    }

 斐波那契查找

 //斐波那契数列1,1,2,3,5,8,13……
    public static int[] fib(){
        int[] f=new int[20];
        f[0]=f[1]=1;
        for (int i=2;i<f.length;i++)
            f[i]=f[i-1]+f[i-2];
        return f;
    }
    public static int fibonacciSearch(int[] a,int key){
        int low=0;
        int high =a.length-1;
        int k=0;//表示斐波那契分割数值的下标
        int mid=0;
        int f[]=fib();
        while (a.length>f[k]-1){
            k++;
        }
        //因为f[k]-1可能大于a的长度，因此需要使用Arrays类，构造新数组并指向a
        int temp[]= Arrays.copyOf(a,f[k]-1);
        //temp={1,8,10,89,1000,1234,0} =>{1,8,10,89,1000,1234,1234}
        for (int i=high+1;i<temp.length;i++){
            temp[i]=a[high];
        }
        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//由于补全数组的原因，找到的mid可能刚好是补的数值
                    return high;
            }
        }
        System.out.println("cant find");
        return -1;
    }