Performance 有没有比这个更好的计算斐波那契的方法？

我做了这个密码。。我需要充分利用它。。我真的需要计算斐波那契数的最佳性能。。请帮忙

我读过一些这类计算的代码，我想我得到了最好的

为我担保这件事。。请

ps：我真的需要大整数。。我将计算大量的斐波那契数

ps2：我用这个算法计算了一些大数字，得到了很好的响应时间。。但我需要知道它是否能更好

ps3：要运行此代码，您需要使用此VM参数

-Xss16384k

（StackSize）

公共类Fibonacci{
私有静态BigInteger[]fibTmp={BigInteger.valueOf（0），BigInteger.valueOf（1）}；
公共静态大整数斐波那契（长v）{
biginger fib=biginger.valueOf（0）；
如果（v==1）{
fib=BigInteger.valueOf（1）；
}else如果（v==0）{
fib=BigInteger.valueOf（0）；
}否则{
BigInteger v1=斐波那契（v-1）；
大整数v2=fibTmp[（int）（v-2）]；
fib=v1.add（v2）；
}
已同步（fibTmp）{
if（纤维长度-1

您的实现对于任何合适的数字都不起作用，因为它会导致堆栈溢出

我看不出有任何理由在这里使用递归。递归性很好，但通常更重（它依赖于语言）。下面是一个简单的

for

循环的工作实现：

private static BigInteger[] fibTmp = {BigInteger.ZERO, BigInteger.ONE};
private static int maxCached = 1;
public static BigInteger fibonacci(int v) {
    if (fibTmp.length<=v) {
        fibTmp = Arrays.copyOf(fibTmp, v*5/4);
    }
    for (; maxCached<v;) {
        maxCached++;
        BigInteger v1 = fibTmp[maxCached - 1];
        BigInteger v2 = fibTmp[maxCached - 2];
        fibTmp[maxCached] = v1.add(v2);
    }
    return fibTmp[v];
}

private static biginger[]fibTmp={biginger.ZERO，biginger.ONE}；
私有静态int maxCached=1；
公共静态大整数fibonacci（int v）{
如果（fibTmp.length首先，您使用的是递归，这在时间和空间复杂性方面都是无效的。您应该使用迭代方法

然后，如果额外的内存或空间不足以解决问题，并且性能非常关键，那么您可能需要预计算所有以后要计算的数字，并将它们存储在阵列中或磁盘上（如果内存太大）。以后您可以在固定时间内获得值。
是的，有更好的方法。这是
日志（n） 
测试并非常有效地计算任意精度的斐波那契值，给定一个正整数作为输入。该算法从一个解决方案改编为：

在本书的链接章节中，有一个对其工作原理的解释（向下滚动至练习1.19），并说明：

这是一个以对数步长计算斐波那契数的聪明算法……这个练习是由Joe Stoy根据Anne Kaldawaij.1990中的一个例子提出的。编程：算法的推导

当然，如果需要一次又一次地计算相同的值，那么可以通过已经计算的结果来获得进一步的性能提升，例如使用映射存储以前的值。
这看起来像java。为了获得最佳性能，语言可能很重要。您能添加语言标签吗？不……忘记语言..是算法性能..这种情况下的语言并不重要！=）更好的算法会更快，无论它是在哪种语言或机器上实现的（当你得到足够大的数字时）。哦，渐近分析的乐趣和乐趣。有一个O（logn）找到斐波那契数的算法。它叫矩阵求幂法。你可以试试。@AndroidDecoded那是
O（logn）
步数。因为
F（n）
有
theta（n）
位，所以计算它的算法没有比
O（n）更好的了
位操作。为了获得更好的性能，您可以用类似（java.math.biginger.multiply具有CUADRADIC复杂性）的内容替换
biginger
private static BigInteger[] fibTmp = {BigInteger.ZERO, BigInteger.ONE};
private static int maxCached = 1;
public static BigInteger fibonacci(int v) {
    if (fibTmp.length<=v) {
        fibTmp = Arrays.copyOf(fibTmp, v*5/4);
    }
    for (; maxCached<v;) {
        maxCached++;
        BigInteger v1 = fibTmp[maxCached - 1];
        BigInteger v2 = fibTmp[maxCached - 2];
        fibTmp[maxCached] = v1.add(v2);
    }
    return fibTmp[v];
}

public static BigInteger fibonacci(int n) {

    int count = n;
    BigInteger tmpA, tmpP;
    BigInteger a = BigInteger.ONE;
    BigInteger b = BigInteger.ZERO;
    BigInteger p = BigInteger.ZERO;
    BigInteger q = BigInteger.ONE;
    BigInteger two = new BigInteger("2");

    while (count != 0) {

        if ((count & 1) == 0) {
            tmpP = p.multiply(p).add(q.multiply(q));
            q = two.multiply(p.multiply(q)).add(q.multiply(q));
            p = tmpP;
            count >>= 1;
        }

        else {
            tmpA = b.multiply(q).add(a.multiply(q).add(a.multiply(p)));
            b = b.multiply(p).add(a.multiply(q));
            a = tmpA;
            count--;
        }

    }

    return b;  

}