Java 以最小运行时间存储带递归的斐波那契序列值

我知道我的代码现在有很多问题，但我只是想在尝试任何东西之前把想法纠正过来。我需要一个方法，它接受一个整数n，返回斐波那契序列中的第n个数字。虽然通常使用递归来解决它，但我必须最小化运行时间，这样当它得到类似于第45个整数的值时，它仍然可以相当快地运行。此外，我不能使用类常量和全局变量

使用递归的正常方式

public static int fibonacci(int n) {
    if (n <= 2) { // to indicate the first two elems in the sequence 
        return 1;
    } else { // goes back to very first integer to calculate (n-1) and (n+1) for (n)
        return fibonacci(n-1) + fibonacci(n-2); 
    }
}

公共静态int fibonacci（int n）{
如果（n我认为您希望使用
映射
而不是
列表
。您可能应该将该集合移到方法之外（以便它可以缓存结果）-

private static Map results=new HashMap（）；
公共静态int-fasterFib（int-n）{
如果（n==0）{
返回0；
}else if（n另一种方法是使用helper方法

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

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

一个类和一个私有静态HashMap怎么样

import java.util.HashMap;

public class Fibonacci {
    private static HashMap<Integer,Long> cache = new HashMap<Integer,Long>();

    public Long get(Integer n) {
        if ( n <= 2 ) {
            return 1L;
        } else if (cache.containsKey(n)) {
            return cache.get(n);
        } else {
            Long result = get(n-1) + get(n-2);
            cache.put(n, result);
            System.err.println("Calculate once for " + n);
            return result;
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        Fibonacci f = new Fibonacci();
        System.out.println(f.get(10));
        System.out.println(f.get(15));
    }

}

import java.util.HashMap；
公共类斐波那契{
私有静态HashMap缓存=新HashMap（）；
公共长get（整数n）{
如果（n您可以使用Map:：computeifassent方法（从1.8开始）重新使用已经计算的数字

import java.util.HashMap;
import java.util.Map;

public class Fibonacci {

    private final Map<Integer, Integer> cache = new HashMap<>();

    public int fib(int n) {
        if (n <= 2) {
            return n;
        } else {
            return cache.computeIfAbsent(n, (key) -> fib(n - 1) + fib(n - 2));
        }
    }
}

import java.util.HashMap；
导入java.util.Map；
公共类斐波那契{
私有最终映射缓存=新HashMap（）；
公共int fib（int n）{
if（n-fib（n-1）+fib（n-2））；
}
}
}
公共类斐波那契{
私有映射缓存=新的HashMap（）；
私有void addToCache（int索引，int值）{
cache.put（索引、值）；
}
私有int getFromCache（int索引）{
返回cache.computeFabSent（索引，this:：fibonacci）；
}
公共整数斐波那契（整数i）{
如果（i==1）
addToCache（i，0）；
else如果（i==2）
addToCache（i，1）；
其他的
addToCache（i，getFromCache（i-1）+getFromCache（i-2））；
返回getFromCache（i）；
}
}
您可以使用memorization（如果此数组的给定索引处的值不是指定的忽略-->返回该值的特定值，则存储数组中已有的值）

代码：

为给定的memo索引赋值，例如：memo[2]
备忘录看起来像[-1，-1，1，…]
每次您需要知道2的fib时，它都会返回备忘录[2]->1
这在较大的数字上节省了大量的计算时间。
私有静态映射缓存=新的HashMap fibonacci（n-1）+fibonacci（n-2））；
private static Map<Integer, Integer> cache = new HashMap<Integer, Integer(){
    {
      put(0, 1);
      put(1, 1);
    }
  };
  /**
   * Smallest fibonacci sequence program using dynamic programming.
   * @param n
   * @return
   */
  public static int fibonacci(int n){
    return n < 2 ? n : cache.computeIfAbsent(n, (key) -> fibonacci( n - 1) + fibonacci(n - 2));
  }

}
你必须使用递归吗？是的。如果我想使用容器来存储值，这是最困难的部分。那么我应该放弃容器的想法吗？回答得很好，只是要指出一点，选择HashMap是因为（大多数情况下）散列是O（1），这很快，不需要迭代就可以找到值！谢谢你的回复。我应该早点说，但我也不允许使用类常量或全局变量。
import java.util.HashMap;
import java.util.Map;

public class Fibonacci {

    private final Map<Integer, Integer> cache = new HashMap<>();

    public int fib(int n) {
        if (n <= 2) {
            return n;
        } else {
            return cache.computeIfAbsent(n, (key) -> fib(n - 1) + fib(n - 2));
        }
    }
}

public class Fibonacci {

    private Map<Integer, Integer> cache = new HashMap<>();


    private void addToCache(int index, int value) {

        cache.put(index, value);


    }

    private int getFromCache(int index) {

        return cache.computeIfAbsent(index, this::fibonacci);

    }


    public int fibonacci(int i) {

        if (i == 1)

            addToCache(i, 0);

        else if (i == 2)
            addToCache(i, 1);
        else
            addToCache(i, getFromCache(i - 1) + getFromCache(i - 2));

        return getFromCache(i);

    }
}

public static void main(String[] args) {
    Scanner s = new Scanner(System.in);
    int n = Integer.parseInt(s.nextLine());
    int[] memo = new int[n+1];
    for (int i = 0; i < n+1 ; i++) {
        memo[i] = -1;
    }

    System.out.println(fib(n,memo));


}

static int fib(int n, int[] memo){
    if (n<=1){
        return n;
    }
    if(memo[n] != -1){
        return memo[n];
    }
    memo[n] = fib(n-1,memo) + fib(n-2,memo);
    return memo[n];
}

 -> int array (all values -1)
 -> length (n+1) // easier for working on index

private static Map<Integer, Integer> cache = new HashMap<Integer, Integer(){
    {
      put(0, 1);
      put(1, 1);
    }
  };
  /**
   * Smallest fibonacci sequence program using dynamic programming.
   * @param n
   * @return
   */
  public static int fibonacci(int n){
    return n < 2 ? n : cache.computeIfAbsent(n, (key) -> fibonacci( n - 1) + fibonacci(n - 2));
  }