斐波那契查找

要点：斐波那契查找的中间结点不再是中间或者插值得到，而是位于黄金分割点附近，即mid = begin + F[k - 1] - 1。其中F[ ]表示斐波那契数列。
对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的两段，中间点则为F[k - 1] - 1。
   

2. 类似的，每一子段也可以用相同方式分割。

3. 但是顺序数列的长度n不一定等于F[k] - 1，所以需要将n增加至F[k] - 1。

package DataStructure;

import java.util.Arrays;

public class FibonacciSearch {
    public static void main(String[] args) {
        int[] arr = {9, 2};
        ChooseSort.sort(arr);
        System.out.println(Arrays.toString(arr));
        int result = search(arr, 9);
        System.out.println(result == -1 ? "无该值" : "索引为：" + result);
    }

    // 取得斐波那契数列
    public static int[] fibonacci(int maxSize) {
        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;
    }

    public static int search(int[] arr, int value) {
        int begin = 0;
        int last = arr.length - 1;
        // 取得斐波那契数组
        int[] fib = fibonacci(20);

        // 找出使得fib[k] - 1大于数组长度的最小k值
        int k = 0;
        while (arr.length > fib[k] - 1) {
            k++;
        }
        // 将数组扩充至fib[k]-1的长度，不够的补零
        int[] newArr = Arrays.copyOf(arr, fib[k] - 1);
        // 将补零值全部换为数组的末尾值
        for (int i = arr.length; i < newArr.length; i++) {
            newArr[i] = arr[last];
        }

        while (begin <= last) {
            int mid = begin + fib[k - 1] - 1;
            if (value < newArr[mid]) {
                last = mid - 1;
                // 对左边序列进行分割，因为左边序列个数为fib[k-1]-1
                // 而fib[k-1]-1 = fib[k-2]-1 + fib[k-3]-1 + 1
                // 所以它的黄金分割点mid = fib[k-2]-1，因此k--
                k--;
            }else if (value > newArr[mid]) {
                begin = mid + 1;
                // 对右边序列进行分割，因为右边序列个数为fib[k-2]-1
                // 而fib[k-2]-1 = fib[k-3]-1 + fib[k-4]-1 + 1
                // 所以它的黄金分割点mid = fib[k-3]-1，因此k-2
                k -= 2;
            }else {
                // 返回mid与arr.length-1之中的最小值，防止越界。
                return Math.min(mid, arr.length - 1);
            }
        }
        return -1;
    }
}