Question

我写过Fibonacci系列如下。我想知道以下是否是使用递归的正确方法，因为我认为我正在循环使用条件的fibonacci函数并且每次都像for循环一样递增i的值。

public class FibanocciSeriesImpl {
static int a,b,i,n;
    static
    {
        a=0; b=1;i=2;
        Scanner sc=new Scanner(System.in);
        System.out.println("Enter the number of elements in the series");
        n=sc.nextInt();

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("The fibnocci series is below");
        System.out.print(a+","+b);
        fibnocciImpl(a,b);
    }
    public static void fibnocciImpl(int a,int b)
    {
        int c=a+b;
        a=b;
        b=c;
        i++;
        System.out.print(","+c);
        if(i<n)
        fibnocciImpl(a,b);

    }
}

Answer 1

斐波那契序列可以用两行代码递归实现，如下所示：

public static long fib(int n) {
    if (n <= 1) return n;
    else return fib(n-1) + fib(n-2);
}

请注意，这不是计算斐波纳契序列的最有效方法，尽管这可能是代码最直接的方法。我会留给你更有效地实施。

Answer 2

虽然已多次说过，但值得重复一遍：按照定义递归计算斐波那契数列，而不使用memoization ---取指数时间（something like { {1}}），这对大型O(1.6^n)不可行（例如n）。

Fibonacci序列也可以在线性时间迭代计算：

n>40

对于它的价值，这是Brainfuck中的相同算法（从我高中时代开始： - ）：

public static long fib(int n) {
    long a = 0, b = 1;
    if (n <= 1) { return n; }
    for (int i = 2; i < n; ++i) {
        int tmp = b;
        b += a;
        a = tmp;
    }
    return b;
}

Answer 3

使用动态编程实现斐波纳契也是可能的，这比递归更有效。

var a = items[inventoryGridView.SelectedIndex].ItemId;

时间复杂度：O（n）额外空间：O（n）

Answer 4

public static void printFIBO(int n) {
    System.out.println(n <=1 : n ? fib(n-1) + fib(n-2));
}

Answer 5

是的，它是递归，不是它不是递归。：）

这是递归，因为你再次调用该函数，但是你误用了递归;你只用递归调用替换了循环。

这是一个简单的例子，将循环更改为递归：

for(int i = 0; i < 3; i++) {
    // do something
}

可以替换为

  i = 0; // global variable
           //so that it maintains the value during recursive function calls
    void func() {
        // do something
        if(i < 3)
            func();
        i++;
    }

但良好的递归使用相同的函数来做一些有意义的事情。

以下是Fibonacci数字的可爱实现：

public static long fib(int n) {
    if (n <= 1) return n;
    else return fib(n - 1) + fib(n - 2);
}

注意我们如何通过调用自身来使函数计算自己，让终止条件发挥作用！因此，当n = 0或1时，它将返回到直接调用者，并将这些数字作为计算的种子。

所以fib(1) = 1和fib(2) = 2 ...当我们返回递归堆栈时，正在计算fib。

请注意，计算作为自上而下的方法是指数级的，但是在记住计算的fib（动态编程）时，向下的方法是O(n)，并且是更有效的方法。

Answer 6

你可以像递归一样进行：

int fib(int i){
if(i == 0 || i ==1) return n;
else return fib(i - 1) + fib(i-2);
}

但更快捷的方法是使用iterativ方式进行操作，因为您可以阅读这里有例子：

Iterative vs Recursive

递归Fibonacci代码

6 个答案: