带有记忆的斐波那契序列仍然比正常的递归解决方案慢

Question

我注意到我的带有记忆功能的递归斐波那契算法仅适用于大于 12 的值。

我将它与其他人的方法实现进行了比较，其中他也传递了一个数组。我认为每次传递一个数组，在重新调用该方法时会占用太多内存，从而使程序变慢，但事实并非如此。

不知何故，我仍然无法理解我的外部数组如何不比正常的递归斐波那契算法快。我认为这可能是因为我的 if 中有许多条件，我检查它是否较慢，但我不确定。

如果可能的话，你会看看我的代码并告诉我我做错了什么或者后台发生了什么吗？

public class Fibonacci2 {
    int memory[];

    public Fibonacci2(int f) {  
        if (memory == null) {
            memory = new int[f+1];

            memory[0] = 0;
            memory[1] = 1;
            memory[2] = 1;
        }   
    }
    
    public int recursive(int f) {
        if (memory[f-1] != 0 && memory[f-2] != 0 && f>2) {
            memory[f] = memory[f-1] + memory[f-2];
        } else if (memory[f-1] == 0 && memory[f-2] != 0 && f>2) {
            memory[f] = recursive(f-1) + memory[f-2];
        } else if (f>2) {
            memory[f] = recursive(f-1) + recursive(f-2);
        }

        return memory[f];
    }
    
}

public class Fibonacci1 {
    public Fibonacci1() {}
    
    public int recursive(int f) {
        if (f > 2) {
            return recursive(f-1) + recursive(f-2);
        } else {
            return 1;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        int fibo = 12;

        Fibonacci1 fiboEx1 = new Fibonacci1();
        Fibonacci2 fiboEx2 = new Fibonacci2(fibo);

        int a = fiboEx1.recursive(fibo);

        long start = System.nanoTime();
        long stop = System.nanoTime();

        System.out.println("fibo of " + fibo + " is " + a);
        System.out.println("Fibonacci time without memorization: " + (stop-start));

        int b = fiboEx2.recursive(fibo);

        start = System.nanoTime();
        stop = System.nanoTime();

        System.out.println("fibo of " + fibo + " is " + b);
        System.out.println("Fibonacci time with memorization: " + (stop-start));
    }
}

Answer 1

我注意到我的带记忆的递归斐波那契算法只适用于大于 12 的值。

我猜你的意思是写“小于 12 的值小于”。无论哪种方式，这都不正确：您的解决方案适用于大于 12 的值，直到结果类型溢出。

也就是说，您的代码存在多个问题。

1. 不要在你的构造函数中测试if(memory==null)。 总是是的。

2. memory[f-1] != 0 && memory[f-2] != 0 && f>2 — 你为什么要在这里测试f > 2？只有在在开头进行测试时，该测试才有意义，以避免访问负数组元素。否则测试是多余的。

3. 整个函数比必要的复杂。将访问记忆值的逻辑分开，使其更清晰、更简单且不易出错：

   public int recursive(int f){
       if (f > 2 && memory[f - 2] == 0) {
           memory[f - 2] = recursive(f - 2);
       }
       if (f > 1 && memory[f - 1] == 0) {
           memory[f - 1] = recursive(f - 1);
       }
       memory[f] = memory[f - 2] + memory[f - 1];
       return memory[f];
   }
   

   ... 但是您当然可以而且应该进一步简化：

   public int recursive(int f){
       if (memory[f] == 0) {
           memory[f] = recursive(f - 2) + recursive(f - 1);
       }
       return memory[f];
   }
   

   这也是一样的。但不是每个函数调用对记忆值进行多次冗余检查，它只是处理自己的值（即f's），其余的调用自己。

4. 从根本上说，将 this 作为具有构造函数和附加函数的类毫无意义：该函数只能用于获取单个值的斐波那契数，此外，该函数在构造函数中需要相同和函数调用（这很容易出错！）。例如，以下代码会使代码崩溃：new Fibonacci2(10).recursive(15)。这也是：new Fibonacci2(1)。好的代码不会允许这样的错误发生。

这是一个没有这些问题的解决方案：

class Fib {
    static int memory[];

    private static void resizeMemory(int newSize, int[] oldValues) {
        if (newSize < 3) newSize = 3;
        memory = new int[newSize];
        System.arraycopy(oldValues, 0, memory, 0, oldValues.length);
    }

    public static int fib(int n) {
        if (memory == null || memory.length <= n) {
            resizeMemory(n + 1, new int[] {0, 1, 1});
        }

        if (n == 0) return 0;
        if (memory[n] == 0) memory[n] = fib(n - 2) + fib(n - 1);
        return memory[n];
    }
}

但我仍然不会真正编写像这样的“真正的”斐波那契实现——维护全局内存缓存会引入复杂性并且没有实际用途。这是一个不使用缓存的高效实现。在实践中，如果您计算 大量 斐波那契数，它只会降低效率，即便如此，这也不太可能成为瓶颈。

为了说明，下面是它的样子：

private static int fibImpl(int n, int a, int b) {
    if (n == 0) return a;
    if (n == 1) return b;
    return fibImpl(n - 1, b, a + b);
}

public static int fib(int n) {
    return fibImpl(n, 0, 1);
}