斐波那契查找

斐波那契数列

斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、····，在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）。

斐波那契查找

斐波那契查找就是在二分查找的基础上根据斐波那契数列进行分割的。在斐波那契数列找一个等于略大于查找表中元素个数的数F[n]，将原查找表扩展为长度为Fn，完成后进行斐波那契分割，即F[n]个元素分割为前半部分F[n-1]个元素，后半部分F[n-2]个元素，找出要查找的元素在那一部分并递归，直到找到。

斐波那契查找与折半查找很相似，他是根据斐波那契序列的特点对有序表进行分割的。他要求开始表中记录的个数为某个斐波那契数小1，及n=F(k)-1；开始将k值与第F(k-1)位置的记录进行比较(及mid=low+F(k-1)-1)，比较结果也分为三种：

（1）相等，则mid位置的元素即为所求；

（2）>，则low=mid+1，k-=2；

说明：low=mid+1说明待查找的元素在[mid+1,high]范围内，k-=2 说明范围[mid+1,high]内的元素个数为n-(F(k-1))=Fk-1-F(k-1)=Fk-F(k-1)-1=F(k-2)-1个，所以可以递归的应用斐波那契查找。

（3））<，则high=mid-1，k-=1。

说明：low=mid+1说明待查找的元素在[low,mid-1]范围内，k-=1 说明范围[low,mid-1]内的元素个数为F(k-1)-1个，所以可以递归的应用斐波那契查找。

在最坏情况下，斐波那契查找的时间复杂度还是O(log2n)，且其期望复杂度也为O(log2n)，但是与折半查找相比，斐波那契查找的优点是它只涉及加法和减法运算，而不用除法，而除法比加减法要占用更多的时间，因此，斐波那契查找的运行时间理论上比折半查找小，但是还是得视具体情况而定。

public class FibonaciiSort {
    public static int maxSize= 20;
    public static void main(String[] args) {
 
        int arr[] = {1,8,10,89,1000,1234};
        int i = fibonaciiSort(arr, 1234);
        System.out.println("下标"+i);
    }
 
 
    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;
    }
    /*
     * @param arr:
     * @param key: 要查找的值
     * @return: int 对应下标
     * @description:
     */
    public static int fibonaciiSort(int arr[],int key){
        int low = 0;
        int high= arr.length-1;
        int k =0; //表示斐波那契分割数值的下标
        int mid = 0;
        int[] f = fib(); //获取到斐波那契数列
 
        //获取斐波那契分割数值的下标
        //在斐波那契数列找一个等于或第一个大于查找表中元素个数的数 F[n]，然后将原查找表的长度扩展为 Fn
        while (high > f[k] -1){
            k++;
        }
        //因为f【k】，可能大于数组长度，因此需要不齐
        //不足部分使用0填充
        int[] temp = Arrays.copyOf(arr, f[k]); //扩充到 f[k]个数组长度
        //用数组最后的数 填充temp
        //举例：
        //temp={1, 8, 48, 88, 89, 899, 1024，0，0} => {1, 8, 48, 88, 89, 899, 1024，1024，1024}
        for (int i = high+1; i < temp.length; i++) {
            temp[i] = arr[high];
        }
 
        //使用whlie循环找到key
        while (low <= high) {
            mid = low + f[k - 1] - 1;//得到mid的下标
 
            if (key < temp[mid]) {//继续向数组前部分查找（左边）
                high = mid - 1;
                //为什么是k--;
                //说明：
                //1.全部元素=前边元素+后边元素
                //2.f[k] = f[k-1] + f[k-2]
                //因为前面的 f[k-1] 个元素，所以我们可以继续拆分，f[k-1] = f[k-2] + f[k-3]
                //即再f[k-1]的前面继续查找，k--
                k--;
            }else if (key>temp[mid]){//继续向数组后部分查找（右边）
                low = mid + 1;
                //为什么是k-2；
                //说明：
                //1.全部元素=前边元素+后边元素
                //2.f[k] = f[k-1] + f[k-2]
                //3.后面右 f[k-2] 个元素，继续拆分
                //即下次循环 mid = f[k-1-2] - 1。
                k -= 2;
            }else{//找到
                //需要确定，返回哪个值
                if(mid<=high){
                    return mid;
                }else{
                    return high;
                }
            }
        }
        return -1;
    }
}