Question

我必须了解这一点。似乎没有明确解释的好指南。功能树是什么样的？

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

假设我Fib(7)，我实际上明白它应该是这样的：

事情是，似乎树呈现为fib(7)实际上意味着fib(6) + fib(5)应该是真的......但是，如果我理解递归而不是{ {1}}实际上是fib(7) + fib(6)但fib(5)尚未投放，因为fib(5)现在会将自己称为fib(6) + fib(4)再次fib(3)将不会被执行，因为fib(3)将自动调用，直到它停在“停止”状态...而不是什么？

如果fib(4)调用fib(7)等等......直到fib(6)，那么所有其他fib(1)函数呢？

每次结果如何实际返回并告诉我fib(n-2)的值是多少？

Answer 1

每次都不返回值，至少不会立即返回。

每次方法调用自身时，它都会将新调用放在堆栈上。此堆栈上的空间有限，因此具有足够递归调用的大数字将引发堆栈溢出异常。这也是为什么你有这种终止条件，告诉它何时停止自我调用。

if (n <= 2)  
{   
    return 1;  
}

在你的方法最后一次在树的每个分支上调用自己之后（当n <= 2并且方法返回1而不是自己调用时），它将展开堆栈，最后评估所有这些调用和总结返回值，在13的情况下返回Fib(7)。

Answer 2

在你理解之前，很难理解错误...

所以函数 fib（7）用 fib（6）+ fib（5）

计算

（使用较小的值调用相同的函数，这会导致函数调用中的函数调用中的函数调用）

fib（6）再次是 fib（5）+ fib（4）
和 fib（5）是 fib（4）+ fib（3）

这个链继续，直到你达到 fib（3）= fib（2）+ fib（1），因为 fib（1）和 fib（2） 1 。这意味着 fib（3）的值 2

现在你可以再退一步看看 fib（4），它是 fib（3）+ fib（2），计算到 2 + 1 ， 3

并且在此阶段我们回到 fib（5） fib（4）+ fib（3）或 3 + 2 或 5

以这种方式，你会追回树，直到再次到达 fib（7），然后计算到 5 + 8 或 13 这是Fibbonacci行的第七个数字的正确值

停止条件是停止调用其他函数并开始将实际值返回给调用该函数的函数。

我希望这有点帮助。

Answer 3

让我解释一下4

  //step- 1) you are passing 4
    static long Fib(4)
    {  //4>2
        if (n <= 2)  
        {   
            return 1;  
        }  
        return Fib(3)//This will call Fib(3) 
+ Fib(2); 
    }
    //step-2
    your n is 3 now
    static long Fib(3)
    {  //3>2
        if (n <= 2)  
        {   
            return 1;  
        }  
        return Fib(2)//This will call Fib(2) 
+ Fib(1); 
    }
    //step-3
    //your n is 2 now
    static long Fib(2)
    {  //2=2
        if (n <= 2)  
        {   //here it will return 1 back to step-2
            return 1;  
        }  
        return Fib(n - 1) + Fib(n - 2); 
    }
    //step-4
    static long Fib(3)
    {  
        if (n <= 2)  
        {   
            return 1;  
        }  
        return Fib(2) 1//we got from step-3 
+ Fib(1)//will call Fib(1) ; 
    }
    //step-5
    //your n is 1
    static long Fib(1)
    {  //1<2
        if (n <= 2)  
        {   //it will return 1 back to step-4
            return 1;  
        }  
        return Fib(n - 1) + Fib(n - 2); 
    }
    //step-6
    static long Fib(3)
    {  
        if (n <= 2)  
        {   
            return 1;  
        }  
        return Fib(2)//-> 1//we got from step-3
 + Fib(1)//->1//we got from step-5 ; 
    //(1+1)=2 will be return back to step-1
    }
    //step-7
    static long Fib(4)
    {  
        if (n <= 2)  
        {   
            return 1;  
        }  
        return Fib(3)//->2//we got it from step-6+ Fib(2)//will call Fib(2); 
    }
    //step-8
    static long Fib(2)
    {  //2=2
        if (n <= 2)  
        {   //This will return back to step-7
            return 1;  
        }  
        return Fib(n - 1) + Fib(n - 2); 
    }
    //step-9
    static long Fib(4)
    {  
        if (n <= 2)  
        {   
            return 1;  
        }  
        return Fib(3)//->2 we already got it from step-6 + Fib(2)//->1// we got it from step-8; 
    //This will return 3(2+1)
    }

关于Fibonacci递归的解释

3 个答案: