这是怎么得到8的？

Question

代码如下：

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

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

输出为 8。 输出应该是 8，但是当我看到这个时，我认为它应该是 7 ((5-1) +(5-2))。

为什么输出是 8？我认为获得 8 的原因可能会使递归不再让我感到困惑。

Answer 1

让我们把它当作代数，我会写f(n)而不是fibonacci(n)以节省空间：

f(5) = f(4) + f(3)
f(5) = f(3) + f(2) + f(2) + f(1)
f(5) = f(2) + f(1) + f(1) + f(0) + f(1) + f(0) + f(1)
f(5) = f(1) + f(0) + f(1) + f(1) + f(0) + f(1) + f(0) + f(1)
f(5) =  1   +  1   +  1   +  1   +  1   +  1   +  1   +  1

Answer 2

因为是递归调用，所以每次调用参数不是0或者1的时候都会再次调用。

fibonacci(7)
-> fibonacci(6) // recursively calls itself with (7-1)
   -> fibonacci(5) // recursively calls itself with (6-1)
      -> fibonacci(4) // recursively calls itself with (5-1)
         -> fibonacci(3) // recursively calls itself with (4-1)
            -> fibonacci(2) // recursively calls itself with (3-1)
               -> fibonacci(1) // recursively calls itself with (2-1)
   -> fibonacci(4) // recursively calls itself with (6-2)
        ...
-> fibonacci(5) // recursively calls itself with (7-2)
   -> fibonacci(4) // recursively calls itself with (5-1)
      -> fibonacci(3) // recursively calls itself with (4-1)
         -> fibonacci(2) // recursively calls itself with (3-1)
            -> fibonacci(1) // recursively calls itself with (2-1)
   -> fibonacci(3) // recursively calls itself with (5-2)
      ...

等等。

想想这样的逻辑，你应该能够计算出它实际返回给初始调用者的内容。

Answer 3

它返回的是fibonacci(n-1)，而不是n-1。当你用 5 调用它时，你会得到：

return fib(4) + fib(3);

fib(4) 返回：

return fib(3) + fib(2);

fib(3) 返回：

return fib(2) + fib(1);

fib(2) 返回：

return fib(1) + fib(0);

一旦到达 fib(1) 或 fib(0)，就返回 1；

向后工作，fib(2) 返回 2：

return 1 /*fib(1)*/ + 1 /*fib(0)*/;

同样的逻辑，fib(3) 返回 2 + 1，或者 3.Fib(4) 返回3 + 2，或者 5.Fib(5) 因此返回 5 + 3，也就是你的 8。

Answer 4

也许这个改编自Structure and Interpretation of Computer Programs（SICP，或向导书）的插图会有所帮助：

切线切线，SICP 是一个非常深刻的编程入门，虽然有时很难。由于它使用 Lisp（而不是 Scheme）作为教学语言，因此自始至终都使用递归。甚至 Lisp 中的迭代过程也是基于递归调用的：

(define (factorial n)
  (define (fact-iter n product)
    (if (> n 1) 
        (fact-iter (- n 1) (* product n))
        product
  ) )
  (fact-iter n 1)
)

(factorial 5)
; returns 120

实际上是iterative。注意：car 返回列表的头部，而cdr 返回尾部。运营商使用prefix notation； (- a b) 是“a - b”，(* a b) 是“a * b”。

这是您的斐波那契程序在 Scheme 中的样子：

(define (fibonacci n)
  (if (or (= n 1) (= n 2))
      1
      (+ (fibonacci (- n 1)) (fibonacci (- n 2)))
  )

Answer 5

不是((5-1) + (5-2))，而是(finonacci(5-1) + fibonacci(5-2))

而finonacci(5-1) 减少为fibonacci(4)，变成(finonacci(4-1) + fibonacci(4-2))，等等。

Answer 6

return fibonacci (n-1) + fibonacci (n-2); 

这实际上不仅仅是在做 (n-1) + (n-2)，而是再次递归调用斐波那契函数。

所以它在做斐波那契 (4) + 斐波那契 (3)。然后该 fib(4) 被评估为 fib(3) + fib(2)，因此它最终返回 fib (3) + fib (2) + fib (3)。同样，这些 fib(3) 中的每一个实际上都是 fib (2) + fib (1)，依此类推。它一直这样崩溃，直到它击中

if (n == 0 || n == 1)

所以它最终是一堆 fib (1) + fib (0) + fib (1)...，即 1 + 1 + 1...，如果你真的打破了，最终会变成 8一直向下。

Answer 7

我还没有看到这种方法。假设您正在存储结果并构建它，其中f[i] 是调用fibonacci(i) 的结果。 0 和 1 是基本情况，其余的都以此为基础：

f[0] = 1
f[1] = 1
f[2] = f[1] + f[0] = 1 + 1 = 2
f[3] = f[2] + f[1] = 2 + 1 = 3
f[4] = f[3] + f[2] = 3 + 2 = 5
f[5] = f[4] + f[3] = 5 + 3 = 8

Answer 8

函数的结果不是(5 - 1) + (5 - 2)，而是fibonacci( 5 - 1 ) + fibonacci( 5 - 2 )或fibonacci( 4 ) + fibonacci( 3 )，即5 + 3。顺序为：

1 1 2 3 5 8

0 1 2 3 4 5

Answer 9

Recursion 实际上与proof by induction 的数学概念密切相关——事实上，斐波那契数列是递归定义的，所以在某种程度上你必须已经用递归的方式思考才能理解它是如何工作的。

为了更好地理解代码，您可以应用beta reduction -- 即将每个函数调用替换为函数本身的主体。

如果fibonacci(n) 转换为fibonacci(n - 1) + fibonacci(n - 2) 那么：

fibonacci(5) = fibonacci(4) + fibonacci(3)
fibonacci(5) = (fibonacci(3) + fibonacci(2)) + (fibonacci(2) + fibonacci(1))

很容易看出这将永远持续下去，除非我们做了特殊情况。在这里，我们知道fibonacci(1) 转换为1，fibonacci(0) 也转换为1。所以我们一直在减少 beta，直到我们只剩下一个，看起来像：

fibonacci(5) = ((1 + 1) + (1 + (1 + 1))) + ((1 + 1) + 1)

因此：

fibonacci(5) = 8

Answer 10

第一个斐波那契数是 1,1,2,3,5,8,... 任何其他数字都是意料之外的。