Java 需要fibonacci搜索算法的帮助吗

我试图将java代码用于斐波那契搜索，我的理解是从 :

设k定义为F中的一个元素，F是Fibonacci数的数组。n=Fm是数组大小。如果数组大小不是斐波那契数，则让Fm为F中大于n的最小数

斐波那契数的数组定义为Fk+2=Fk+1+Fk，当k≥ 0，F1=1，F0=0

要测试项目是否在有序编号列表中，请执行以下步骤：

设置k=m。 如果k=0，则停止。没有对手；该项不在数组中。 将项目与Fk中的元素进行比较−1. 如果项目匹配，请停止。 如果项目小于条目Fk−1，从位置Fk丢弃元素−1+1到n。设置k=k− 1并返回到步骤2。 如果项目大于条目Fk−1，放弃从位置1到Fk的图元−1.将其余图元从1重新编号为Fk−2，设置k=k− 2，然后返回到步骤2

以下是我的代码：

package com.search.demo;

public class FibonacciSearch {

static int[] a = {10,20,30,40,50,60,70,80,90,100};

static int required = 70;
static int m = 2;
static int p = 0;
static int q = 0;


/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    FibonacciSearch fs = new FibonacciSearch();
    fs.findm();
    fibSearch(required);
}

private void findm(){
    //here you have to find Fm which matches size of searching array, or which is close to it.
    int n = a.length;
    int fibCurrent = 1;
    int fibPrev1 = 1;
    int fibPrev2 = 0;

    while(n > fibCurrent){
        fibPrev2 = fibPrev1;
        fibPrev1 = fibCurrent;
        fibCurrent = fibPrev1 + fibPrev2;
        m++;
    }
    p = m-1;
    q = m-2;
}

public static int fibSearch(int no){
    for(;;){

        if(m == 0){
            System.out.println("not found");
            return -1;
        }
        int j = f(p);

        if(no == a[j]){
            System.out.println("found at "+p);
        }else if(no < a[j]){
            m = p;
            p = m - 1;
            q = m - 2;

        }else if(no > a[j]){
            m = q; // as per the step 6..
            p = m-1;
            q = m-2;
        }
    }
    //return m;
}

public static int f(int val){

    if(val == 2 || val == 1 || val == 0){
        return 1;
    }
    return (f(val-1) + f(val-2));
}


}

package com.search.demo；
公共类FibonacciSearch{
静态int[]a={10,20,30,40,50,60,70,80,90100}；
所需静态int=70；
静态int m=2；
静态int p=0；
静态int q=0；
/**
*@param args
*/
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
FibonacciSearch fs=新的FibonacciSearch（）；
fs.findm（）；
fibSearch（必选）；
}
私有void findm（）{
//在这里，您必须找到匹配搜索数组大小的Fm，或者与之接近的Fm。
int n=a.长度；
电流=1；
int-1=1；
int=2=0；
而（n>当前）{
fibPrev2=fibPrev1；
fibPrev1=fibCurrent；
fibCurrent=fibPrev1+fibPrev2；
m++；
}
p=m-1；
q=m-2；
}
公共静态整数搜索（整数编号）{
对于（；；）{
如果（m==0）{
System.out.println（“未找到”）；
返回-1；
}
int j=f（p）；
如果（否==a[j]）{
System.out.println（“位于”+p）；
}如果（否a[j]）{
m=q；//按照步骤6。。
p=m-1；
q=m-2；
}
}
//返回m；
}
公共静态int f（int val）{
如果（val==2 | | val==1 | | val==0）{
返回1；
}
返回值（f（val-1）+f（val-2））；
}
}

请纠正我做错了什么，并帮我弄清楚

我看到了这一点，但我无法理解

while(n > fibCurrent){
                      fibPrev2 = fibPrev1;
                      fibPrev1 = fibCurrent;
                      fibCurrent = fibPrev1 + fibPrev2;
                      m++;
                    }

findm（）函数中的这一部分实际上是比较第n个斐波那契数，但根据算法，它应该是截至该点的斐波那契数的累积和。

---

相反，您可以在findm的while循环中搜索元素。

最后，我能够解决这个难题，这让我停下了脚步

我认为下面的代码应该可以帮助像我一样陷入困境的人

package com.search.demo;

public class FibonacciSearch {

int a[] = {10,20,30,40,50,60,70,80,90,100};
static FibonacciSearch fs;

/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    fs = new FibonacciSearch();
    int location = fs.find(70);
    if(location < 0){
        System.out.println("number not found..");
    }else{
        System.out.println("found at location "+location);
    }
}

private int find(int no){
    int n = a.length;
    int m = findFm(n);                  //m = Fm iff n is Fibonacci number else returns Fm+1
    int p = fibSequenceIterative(m-1);  //p = Fm-1, always a fibonacci number
    int q = fibSequenceIterative(m -2); //q = Fm-2, always a fibonacci number

    while(true){
        if(no == a[m]){
            return m;
        }else if (no < a[m]){
            if(q == 0){
                return -(m - 1);// we crossed 0th index in array, number not found.
            }                   
            m = m - q;  //moved to 1 step left towards a fibonacci num
            int tmp = p;//hold this temporarily
            p = q;      //move p to 1 step left into another fibonacci num
            q = tmp - q;//moved q to 1 step left....
        }else if(no > a[m]){
            if(p == 1){
                return -m;//we reached 0th index in array again and number not found..
            }
            m = m + q;
            p = p - q;
            q = q - p;
        }
    }

}

private int findFm(int n){
    int prev = 1;
    int curr = 1;
    int next = 0;

    if(n == 0){
        next = 0;
        return -1;
    }else if(n == 1 || n == 2){
        next = 1;
        return 1;
    }else{
        for(int i = 3; ; i++){
            next = prev + curr;
            prev = curr;
            curr = next;
            System.out.println("prev = "+prev+" curr = "+curr+" next = "+next);
            if(n <= curr){
                System.out.println("n = "+n+" curr = "+curr);
                return i;
            }
        }
        //return -1;//we should not get here..
    }


}

/* Iterative method for printing Fibonacci sequence..*/
private int fibSequenceIterative(int n){
    int prev = 1;
    int curr = 1;
    int next = 0;

    if(n == 0){
        next = 0;
        //return 0;
    }else if(n == 1 || n == 2){
        next = 1;
        //return 1;
    }else{
        for(int i = 3; i <= n; i++){
            next = prev + curr;
            prev = curr;
            curr = next;
        }
        return next;
    }
    return next;
}


}

package com.search.demo；
公共类FibonacciSearch{
INTA[]={10,20,30,40,50,60,70,80,90100}；
静态光纤放大器；
/**
*@param args
*/
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
fs=新的FibonacciSearch（）；
int location=fs.find（70）；
如果（位置<0）{
System.out.println（“未找到编号”）；
}否则{
System.out.println（“在位置找到”+位置）；
}
}
私有整数查找（整数编号）{
int n=a.长度；
int m=findFm（n）；//m=Fm如果n是斐波那契数，否则返回Fm+1
int p=fibonacci（m-1）；//p=Fm-1，始终是一个斐波那契数
int q=fibonacci（m-2）；//q=Fm-2，始终是一个fibonacci数
while（true）{
如果（否==a[m]）{
返回m；
}否则，如果（否a[m]）{
如果（p==1）{
return-m；//我们再次到达数组中的第0个索引，但找不到编号。。
}
m=m+q；
p=p-q；
q=q-p；
}
}
}
专用int findFm（int n）{
int-prev=1；
int curr=1；
int next=0；
如果（n==0）{
next=0；
返回-1；
}else如果（n==1 | | n==2）{
next=1；
返回1；
}否则{
for（int i=3；；i++）{
下一个=上一个+当前；
上一次=当前；
curr=next；
System.out.println（“prev=“+prev+”curr=“+curr+”next=“+next”）；
如果（n10.So）m=7

现在，p和q是两个连续的斐波那契数，它们总是决定数组的除法间隔

请阅读以下内容：

取N=54，这样N+1=55=F[10]。我们将搜索排序后的数组：A[1]，…，A[54]，包括在内。数组索引严格位于两个斐波那契数之间：0<55。此搜索使用的不是中点，而是从F[10]=55向下的下一个斐波那契数，即F[9]=34.我们不是将搜索间隔一分为二，两边各50%，而是粗略地除以黄金分割率，左边约62%，右边约38%。如果y==A[34]否则我们有两个较小的区间来搜索：0到34和34到55，不包括端点。如果你有两个连续的斐波那契数，那么很容易用减法向后倒退，这样，下一个从34返回的数字是55—34＝21。到55用下一个斐波那契数来表示：34-21=13。整个区间[34，55]的长度为21，我们从开始处经过13，到34+13=47。请注意，这不是