Question

这是我使用java

实现的斐波纳契序列

/**
 * Returns nth fibonacci number
 */
public class fib {

   public static void main(String[] args){
      System.out.println(fibonacci(12));
   }

   public static int fibonacci(int n) {
      if (n == 0){
         return 0;
      } else if (n == 1){
         return 1;
      } else {
         return fibonacci(n - 1) + fibonacci(n - 2);
      }
   }
}

但是使用递归对这种方法的可视化让我觉得它会快得多。这是fib（5）的可视化。 http://imgur.com/a/2Rgxs 但这有我的想法，当我们从递归路径的底部冒泡时我们计算了fib（2），fib（3）和fib（4），然后我们在右上角重新计算fib（3）科。所以我在想什么，当我们冒泡回来为什么不保存从左分支计算的fib（3），所以我们不像我的方法当前做的那样在右分支上进行任何计算，就像哈希表在回来时一样。我的问题是，我该如何实现这个想法？

Answer 1

如果您想添加HashMap并继续使用原始方法，请尝试以下操作：

static HashMap<Integer, Integer> values = new HashMap<Integer, Integer>();

public static void main(String[] args){
    values.put(0, 0);
    values.put(1, 1);
    System.out.println(fibonacci(12));
}

public static int fibonacci(int n) {
    if (values.containsKey(n)){
        return values.get(n);
    } else {
        int left = values.containsKey(n - 1) ? values.get(n - 1) : fibonacci(n - 1);
        values.put(n - 1, left);
        int right = values.containsKey(n - 2) ? values.get(n - 2) : fibonacci(n - 2);
        values.put(n - 2, right);
        return left + right;
    }
}

如果你更频繁地调用它，这种方法可能会非常快，因为斐波那契结果已经存储在values中（当然这也可以通过其他方法完成）：

public static void main(String[] args){
    values.put(0, 0);
    values.put(1, 1);
    System.out.println(fibonacci(12));
    System.out.println(fibonacci(11));
    System.out.println(fibonacci(10));
}

Answer 2

对于快速计算，根本不需要递归 - 只需移动中间结果

public static int fibonacci(int n) {
  if (n == 0) {
  return 0;
  } else {
    int npp = 0; // pre-previous number
    int np = 1; // previouse number
    int r = 1; // current number, eventually the result
    for (int i = 2; i <= n; i++) {
      r = np + npp;
      npp = np;
      np = r;
    }

    return r;
  }
}

Answer 3

为避免重复计算，您可以使用动态编程。顺便说一句，这不是内存优化的解决方案，但它可以比递归解决方案更快。

public static int fibonacci(int n)
{    
    int f[] = new int[n+1];

    for (int i = 0; i <= n; i++) {
        if(i == 0 || i == 1) {
            f[i] = i;
        }
        else {
            f[i] = f[i-1] + f[i-2];
        }
    }

    return f[n];
}

使用java进行Fibonacci序列修剪

3 个答案: