Implementación de Fibonacci Search con Java

1. ¿Qué es la búsqueda de Fibonacci?

La búsqueda de Fibonacci se basa en la búsqueda binaria basada en la secuencia de Fibonacci. Encuentre un número F [n] que sea ligeramente mayor que el número de elementos en la tabla de búsqueda en la secuencia de Fibonacci, y expanda la tabla de búsqueda original a una longitud de F [n] (si desea agregar elementos, repita el último elemento hasta Satisfaga los elementos F [n]) y luego complete la división de Fibonacci, es decir, los elementos F [n] se dividen en la primera mitad de los elementos F [n-1] y la segunda mitad de los elementos F [n-2], Averigüe qué parte del elemento desea encontrar y recurse hasta que lo encuentre.

2. Requisitos de algoritmo

La tabla de búsqueda es una tabla ordenada almacenada secuencialmente

Tercero, el proceso de búsqueda.

1. El principio de búsqueda de Fibonacci es similar a los dos anteriores, excepto que se cambia la posición del nodo medio (medio). ¿Medio no proviene del medio o la interpolación, sino que se encuentra cerca del punto dorado? El punto de corte, es decir, medio = bajo + F (k-1) -1? (F significa secuencia de Fibonacci), como se muestra en la figura a continuación
   
2. Comprensión de F (k-1) -1:

• De las propiedades de la secuencia de Fibonacci F [k] = F [k-1] + F [k-2], podemos obtener (F [k] -1) = (F [k-1] -1) + ( F [k-2] -1) +1. Esta fórmula explica: siempre que la longitud de la tabla de secuencia sea F [k] -1, la tabla se puede dividir en dos secciones de longitud F [k-1] -1 y F [k-2] -1, como se muestra en la figura anterior Mostrar Entonces, la posición media es mid = low + F (k-1) -1

• Del mismo modo, cada subsegmento también se puede dividir de la misma manera

• La longitud n de la tabla de secuencia no es necesariamente exactamente igual a F [k] -1, por lo que la longitud n de la tabla de secuencia original debe aumentarse a F [k] -1. El valor de k aquí puede ser siempre que F [k] -1 sea mayor o igual que n, que se obtiene mediante el siguiente código: después de que la longitud de la tabla de secuencia aumenta, la nueva posición (de n + 1 a la posición F [k] -1) , Todos asignados al valor de n posición.

Cuatro, implementación de código

import java.util.Arrays;

public class FibonacciSearch {
    public static void main(String[] args) {
        int[] array = {1,8,10,89,1000,2000};
        System.out.println("index="+fibonacciSearch(array,-1));
    }

    /**
     * @return 斐波那契数列
     */
    public static int[] fibonacciSequence(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;
    }

    /**
     * 斐波那契查找
     * @param arrays 传入数组
     * @param value 待搜索的值
     * @return 下标
     */
    public static int fibonacciSearch(int[] arrays, int value) {
        int left = 0;
        int right = arrays.length - 1;
        int mid = 0;
        //存放斐波那契数列
        int[] fibArray = fibonacciSequence(10);
        //表示斐波那契分割数值的下标
        int fibIndex = 0;
        //获取到斐波那契分割数值的下标
        while (right > fibArray[fibIndex] - 1) {
            fibIndex++;
        }

        //fibArray[fibIndex]的值可能大于a的长度，因此需要构建一个新数组，不足的部分会使用0填充
        int[] temp = Arrays.copyOf(arrays, fibArray[fibIndex]);

        //将新填充的内容替换为最后的数
        //例：temp = {1,3,4,6,9,11,0,0} => {1,3,4,6,9,11,11,11}
        for (int i = right + 1; i < temp.length; i++) {
            temp[i] = arrays[right];
        }
        //使用while来循环处理，找到value，前提是左指针在右指针前边
        while (left <= right) {
            mid = left + fibArray[fibIndex - 1] - 1;
            //当查找的值小于当前值时应该向数组的前边遍历
            if (value < temp[mid]) {
                right = mid - 1;
                //斐波那契数向前移一位
                fibIndex--;
            }
            //当查找的值小于当前值时应该向数组的后边遍历
            else if (value > temp[mid]) {
                left = mid + 1;
                fibIndex -= 2;
            } else {
                if (mid <= right) {
                    return mid;
                } else {
                    return right;
                }
            }
        }
        return -1;
    }
}