Fibonacci递归如何在C＃中工作？

Question

I am trying hard to understand the Fibonacci code below:

private static int mtdFibonacci(int number)
    {
        if (number == 0) return 0; 
        if (number == 1) return 1; 

        return fncRecursive(number - 1) + fncRecursive(number - 2);
    }

Basically, I am having a hard time creating it as a function on how did an input of 7, equals to 13. Although the answer is correct since the 7th element of Fibonacci sequence is 13:

1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th
1    1   2   3   5  8   13  21  34   55

Now I am trying to replicate the code on my own paper on how the Fibonacci recursive work and how does c# solve it:

if n is 7:
return F(7) = F(7-1) + F(7-2) 
return F(7) = F(6) + F(5)
return F(7) = [F(5) + F(4)] + [F(4) + F(3)]
return F(7) = {[F(4) + F(3)] + [F(3) + F(2)]} + {[F(3) + F(2)] + [F(2) + F(1)]}
return 15?

I tried to check online but there is no explanation on how does this correct recursive function for Fibonacci sequence works. The code is correct and the output is correct but I cannot replicate it using on my paper sequence above. Like the input of 7 is 15 to me.

Answer 1

Here's a way that I like to explain recursion to beginners.

Let's imagine a slightly simpler "pseudo code" language version of your program:

f(n) => if n < 3 then 1 else f(n-1) + f(n-2)

That's not legal C#, but read it over and make sure you understand the parts here.

Now we are going to play a little game just with text . The rules of the game are:

• If we see f(some number) then we replace it with ( the if expression with all the n's changed to some number ) .

We'll need more rules in a minute, but let's start with that one. Suppose we have:

f(5)

We follow the rule. We replace it with

(if 5 < 3 then 1 else f(5-1) + f(5-2))

Next rules:

• number < number is replaced with either true or false
• number - number is replaced with their difference
• number + number is replaced with their sum.
• (number) is replaced with number provided that there is no f before ( .f

OK, apply those rules:

(if false then 1 else f(4) + f(3))

Final rule:

• if false then X else Y is replaced with Y. if true then X else Y is replaced with X.

Apply it:

(f(4) + f(3))

Now apply the first rule again:

((if 4 < 3 then 1 else f(4-1) + f(4-2)) + (if 3 < 3 then 1 else f(3-1) + f(3-2))

Keep applying rules:

((if false then 1 else f(3) + f(2)) + (if false then 1 else f(2) + f(1))
(f(3) + f(2)) + (f(2) + f(1))

Let's skip a few steps here. You see that f(3) is going to be replaced with (f(2) + f(1)) , that f(2) and f(1) are going to be replaced with (1) , right?

(((f(2) + f(1)) + (1)) + ((1) + (1))
(((f(2) + f(1)) + 1) + (1 + 1)
(((f(2) + f(1)) + 1) + (2)
(((f(2) + f(1)) + 1) + 2

Again, skip a few steps. If they're not clear then do them yourself by hand

((((1) + (1)) + 1) + 2
(((1 + 1) + 1) + 2
(((2) + 1 ) + 2
((2 + 1)) + 2
((3)) + 2
(3) + 2
3 + 2
5

And we're done. By just a few simple rules of string substitution we have deduced that f(5) is equal to 5.

You can think of function activation in general in simple functions like these as simply "what if I had the function body with all its formal parameters replaced with their argument values?" If you think about it like that, then recursion becomes more straightforward.

Of course that is not how this is really implemented by the runtime, and this ignores a lot of aspects of control flow, variable mutation, and so on. But as a way to understand recursion early in your career, I think it is a pretty good one.

Answer 2

You just need to carefully expand your sequence, that is all, no magic here.

F(7) = F(6) + F(5)
     = F(5) + F(4) + F(4) + F(3)
     = F(4) + F(3) + F(3) + F(2) + F(3) + F(2) + F(2) + F(1)
     = F(3) + F(2) + F(2) + F(1) + F(2) + F(1) + F(2) + F(2) + F(1) + F(2) + F(2) + F(1)
     = 2 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1
     = 13

Answer 3

{[F(4) + F(3)] + [F(3) + F(2)]} + {[F(3) + F(2)] + [F(2) + F(1)]}
=   3  +   2   +    2  +   1    +     2  +   1   +    1  +   1 = 13

Answer 4

The I'm reading your question is what the logic behind above algorithm. One thing I strong believe is "One size does not fit all", this is one good example of it.

A quick solution to calculate nth Fibonacci number is recursively add numbers until the nth loop is finished. On the contrary the above algorithm is trying to deduce the nth Fibonacci number in reverse order.

The Goal here is to find nth Fibonacci number which by definition must be summation of previous two numbers which in turn will be summation of previous two numbers.

Going by this definition you can see from the graph I've created that x must be summation of y = x - 1 and z = x - 2 and so.