2.查找算法复习

public class Search {

    // 顺序查找法
    public static int SeqSearch(int[] a,int key){
        for(int i=0;i<a.length;i++)
            if(a[i]==key) return  i;
        return -1;
    }
    //折半查找
    public  static  int BinarySearch1(int[] a,int key){
        int head=0,tail=a.length-1;
        int mid;
        while(head<=tail){
            mid=(head+tail)/2;
            if(a[mid]==key) return  mid;
            else if(a[mid]> key)  tail=mid-1;
            else  head=mid+1;
        }
        return -1;
    }
    // 折半查找  递归形式
    public  static  int BinarySearch2(int[] a,int key,int head,int tail) {
        int mid = (head + tail) / 2;
        if (a[mid] == key) return mid;
        if (a[mid] > key) return BinarySearch2(a, key, head, mid - 1);
        if (a[mid] < key) return BinarySearch2(a, key, mid + 1, tail);
        return -1;
    }

    //折半查找 优化版 也叫：插值查找
    public  static  int BinarySearch3(int[] a,int key){
        int head=0,tail=a.length-1;
        int mid;
        while(head<=tail){
            mid=head+(key-a[head])/(a[tail]-a[head])*(tail-head);
            if(a[mid]==key) return  mid;
            else if(a[mid]> key)  tail=mid-1;
            else  head=mid+1;
        }
        return -1;
    }

    /* 随着斐波那契数列的递增，前后两个数的比值会越来越接近0.618
    斐波那契查找  二分查找的一种提升算法，通过运用黄金比例的概念在数列中
     选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法*/
    public  static  int BinarySearch4(int[] a,int key){
        int head=0,tail=a.length-1;
        int mid;
        int[] f = new int[20];
        // 构造一个斐波那契数组 f
        Fibonacci(f);
        int k=0;
        while (key>f[k]-1){    //计算key在斐波那契数列的位置 （8，13） 中
            ++k;
        }
        int[] temp =new int[f[k]-1]; //定义了 12长的数组
        System.arraycopy(a,0,temp,0,a.length);  //构建temp数组 ，是防止使用a数组中 mid大于a.length 导致报错 
        for (int i=a.length;i<f[k]-1;i++)   
            temp[i]=a[a.length-1];  

        while(head<=tail){
            mid=head+f[k-1]-1;
            if(key<temp[mid])
            {
                tail=mid-1;
                k-=1;
            }
            else if(key>temp[mid])
            {
                head=mid+1;
                k-=2;
            }
            else
            {
                if(mid<key)
                    return mid; //若相等则说明mid即为查找到的位置
                else
                    return key-1; //若mid>=n则说明是扩展的数值,返回n-1
            }
        }
        return -1;
    }
    //  构造一个斐波那契数组
    public static void Fibonacci(int[] f){
        f[0]=0;
        f[1]=1;
        for (int i=2;i<20;i++){
            f[i]=f[i-1]+f[i-2];
        }
    }



    public static void main(String[] args) {
          int[] a ={1,3,5,7,9,11,13,15};
        System.out.println(SeqSearch(a,9));
        System.out.println(BinarySearch1(a,9));
        System.out.println(BinarySearch2(a,9,0,a.length-1));
        System.out.println(BinarySearch3(a,9));
        System.out.println(BinarySearch4(a,9));
    }



}

斐波那契查找算法 总结： 

基本思想：二分查找的一种优化算法，基本的二分查找：通过折半，差值查找，是通过 key 与最小值和最大值进行比例性质 区分查询，而斐波那契查找 是通过 黄金比例 0.618分割，而恰巧随着斐波那契数列的递增，前后两个数的比值会越来越接近0.618，所以利用了斐波那契数组， 斐波那契查找属于一种有序查找算法。

复杂度分析：最坏情况下，时间复杂度为O(log2n)，且其期望复杂度也为O(log2n)

代码中 构建 f 数组 就是为创造 0.618这个比例环境