斐波那契 (黄金分割法)查找——推导 详细

介绍

斐波那契查找原理和二分查找相似，改变了中间结点（mid）的位置，mid 不再是中间得到，而是位于黄金分割点附近，即mid=low+F(k-1)-1（F 代表斐波那契数列）【这个暂且先记住】
最初我们使用顺序查找，从头到尾依次遍历比对，发现效率较低
然后使用二分查找，每次选择中间位置的值和目标值进行比对，根据比对情况，选择向左边还是右边继续查找。
二分比对的是中间位置，斐波那契查找的是黄金分割点，所以这是一个类似的情况。
为什么需要把斐波那契数列引入呢？我们看一下斐波那契数列的值，并且计算一下相邻两者之间比例，发现这个比例在往黄金分割靠近。

      1 1 2 3 5 8 13 21 34
      1 1  -> 1
      1 2  -> 0.5
      2 3  -> 0.667
      3 5  -> 0.6
      5 8  -> 0.625
      8 13 -> 0.615
      ....  

再看二分查找

对于有序序列【0，1，2，3，4，5，6】，比如我们查找1
left = 0 right = 6 mid = （left + right) / 2 = (0 + 6) /2 = 3
mid 还可以写成 = left + (right - left) / 2 = 0 + (6 - 0) / 2 = 3【这才是真正的写法】
接下来，就需要判断我们要找的值和计算得到中间索引对应值的大小关系，如果findValue比中间值小，就到左边的序列继续找，否则就去右边的序列继续找。那么这个左右序列是什么呢？
上面的左序列【0，1，2】
上面的右序列【4，5，6】
根据我们计算的mid，划分的左右两个部分。再加上我们计算的mid，那么是不是之前的原序列被分割成了三个部分！！！也就是说，原本序列的长度=左序列长度 + 右序列长度 + 1
然后我们再反推，如果我们已经知道了分割的方法，那么mid的值是不是可以通过序列长度计算出来？
答：只要我们知道了左边序列的长度，知道了left。通过left + 左边序列的长度，得到的就是mid的值，上面就对应 0 + 3 = 3。没错，这样就都联系起来了。
通过上面的介绍，我们可以通过left,right得到mid，推导出如何分割成三个部分。
我们也可以通过三个分割，计算出mid值。

斐波那契查找

既然可以通过分割得到mid值，我们是不是可以将一个序列分成三部分：左序列 + 1 + 右序列
斐波那契数列的计算公式为：F[k] = F[k-1] + F[k-2]，这个和我们需要的三部分差个1。想办法构造出1：(F[k] -1 )= (F[k-1] -1) +( F[k-2] -1) + 1，这个样子是不是就满意多了，首先序列被分成了三个部分，并且分割出来的(F[k] -1 )，(F[k-1] -1)，( F[k-2] -1) 形式上都是一样的。都是【一个数列元素 - 1】，这个看起来非常完美。之所以说完美，是如果我们需要往左边的序列继续分割，他的长度满足我们继续分割的要求，往右边也是一样。既然已经分割完毕，是不是就可以通过分割计算出mid的索引值了：mid=low+F(k-1)-1

编码阶段

我们可以看出，我们的一切一切的前提都是这个有序序列的长度满足F[k] -1,需要将原来的顺序表长度 增加至 F[k]-1。所以我们首先需要根据原来序列的长度，找到一个最小的k,然后创建一个临时数组，将长度控制在F[k]-1

        int k = 0;
        // 这里f[k]是保存的斐波那契数列值
        // 长度等于了，就不需要继续扩了
        while (array.length > f[k] - 1) {
            k++;
        }
        // 或者
        // high 和 length 长度之前差1
        // 这也是和老韩写的不一样的地方，他的代码会出越界异常
        while (right >= f[k] - 1) {
            k++;
        }
        // 

接下来就需要向扩容到一个临时数组，然后在扩容数组中继续查找。

        int[] temp = Arrays.copyOf(array, f[k] - 1 );
        // 实际上需求使用array数组最后的数填充 temp
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = array[high];
        }

接下来就是利用循环不断进行查找。整个完整的代码如下

   // 计算的数列的长度
    public static int maxSize = 20;
	// 测试的主方法
    public static void main(String[] args) {
        int arr[] = { 1, 8, 10, 89, 1002};
        System.out.println("index = " + ffind(arr, 1002));
        System.out.println("index = " + f(arr, 1002));
    }
    // 得到数列
     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;
    }
    // 查找
    public static int fibS(int[] array, int key) {
        int low = 0;
        int high = array.length - 1;
        int k = 0; // 斐波那契数列的下标
        int mid = 0; // 存放mid值
        int f[] = fib(); // 获取到斐波那契数列
        // 获取到斐波那契分割数值的下标
        while (high >= f[k] - 1) {
            k++;
        }
        // 因为 f[k] 值 可能大于 a 的 长度,因此我们需要使用Arrays类,构造一个新的数组,并指向temp[]
        // 不足的部分会使用0填充
        int[] temp = Arrays.copyOf(array, f[k] - 1 );
        // 实际上需求使用array数组最后的数填充 temp
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = array[high];
        }
        // 利用循环查找key
        while (low <= high) { // 满足这个条件,即可以找到

            mid = low + f[k - 1] - 1;
            if (key < temp[mid]) { // 继续向左边查找
                high = mid - 1;
                // 使用k--的原因
                // 说明:
                // 1.全部元素 = 前面的元素 + 后边元素 + 1
                // 2.f[k] - 1 = f[k-1]-1 + f[k-2]-1 + 1
                // 因为 前面有 f[k-1]-1个元素,所以可以继续拆分 f[k-1]-1 = f[k-2]-1 + f[k-3]-1 +1
                // 即 在 f[k-1] 的前面继续查找 k--
                // 即下次循环 mid = f[k-1-1]-1 + left
                k--;
            } else if (key > temp[mid]) { // 继续向右边查找
                low = mid + 1;
                // 使用k -= 2 的原因
                // 说明
                // 1.全部元素 = 前面的元素 + 后边元素 + 1
                // 2.f[k] - 1 = f[k-1]-1 + f[k-2]-1 + 1
                // 因为 后面有 f[k-2]-1个元素,所以可以继续拆分 f[k-2]-1 = f[k-3]-1 + f[k-4]-1 +1
                // 即 在 f[k-2] 的前面继续查找 k-=2
                // 5.即下次循环 mid = f[k - 1 - 2] - 1
                k -= 2;
            } else { // 找到了！！！
                // 需要确定,返回的是哪个下标
                //  因为mid 是根据划分计算出来的
                // 所以就可能出现得到的mid是在我们扩容的数组里面
                // 但是此时的right还依旧是最初的最右边的数。
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }