C# 关于斐波那契递归的解释

我必须对此有所了解。 似乎没有明确解释的好指南。 函数树是什么样子的

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

静态长Fib（int n）
{  
如果（nwell）在你理解之前，复发是不容易理解的

所以函数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
哪一个是斐波那契行第七个数字的正确值

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

我希望这会有所帮助。
它不会每次都返回一个值，至少不会立即返回

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

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

if（n让我解释一下

  //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)
    }

//步骤-1）您正在通过4
静态长纤维（4）
{  //4>2
if（n2）
如果（n）将每次调用看作方法的一个单独实例。Fib（带参数7）创建另一个Fib实例（带参数6），然后等待它返回一个值。然后它创建另一个Fib实例（带参数5），然后等待它返回一个值。然后它将两个值相加。这是在堆栈的帮助下完成的。您调用的每个方法都将存储在堆栈中，包含执行所有工作并继续工作所需的所有信息。因此，当您调用
f（6）
时，它将添加到堆栈顶部，而
f（7）
位于
f（6）下
。完成
f（6）
后，它将从堆栈中删除
f（6）
，现在您可以在
f（7）
中继续，因为您在堆栈中存储了所有需要的信息以继续…旁注：这是一种非常低效的计算斐波那契数的方法。（指数时间）