Question

我试图理解，总和来自哪里？我知道递归是什么，但是我无法弄清楚int i是如何得到总和的。我已经阅读了有关堆栈的信息……但是我还是不明白。请帮忙：）这是代码：

static void Main(string[] args)
{
    int i = RecursiveMethod(1,3);
    //Console.ReadLine();
}

static int RecursiveMethod(int a, int b)
{
    Console.WriteLine(a);
    if (a == b)
    {
        return a;
    }
    else 
    {
        return a + RecursiveMethod(a + 1, b);
    }
}

Answer 1

让我们逐步介绍您致电RecursiveMethod(1,3);

时发生的情况

代码进入else分支，因为a不等于b
致电RecursiveMethod(2,3)
代码再次进入else分支，因为a不等于b
致电RecursiveMethod(3,3)
如果满足if条件，我们将获得第一个返回3的返回
现在我们进入了步骤2的else分支，因为返回了RecursiveMethod(3,3)。步骤2像这样：return 2 + RecursiveMethod(3,3)变成：2 + 3并返回5
现在我们到了最后一个退货，我们在步骤1中，不再有内部退货。步骤2返回了5，因此return 1 + 5 = 6

每次递归调用都会使您更深入。您必须在某个时候按回车键，否则该方法将继续被调用，最终您将得到一个StackOverFlowException。这是因为每个方法都有一个堆栈，其中保留有参数，局部变量和其他内容，当您继续调用该函数时，所有这些值将一遍又一遍地推送到堆栈中，每次调用最终都会用完堆栈空间。

您命中的return语句数应等于您进行的递归调用数。不包括返回到呼叫者的最后一次返回。在上面的函数中，我们进行了两次递归调用，并击中了2个返回值，最后一个返回了Main。

Answer 2

i值来自递归本身的结果。
第一次调用RecursiveMethod时，它将以两种不同的方式完成：

1）如果a返回a == b
2）返回方法RecursiveMethod

的（递归）调用结果

在您的示例中，使用(1,3)调用该方法时，它将在第二种情况下运行，因此将需要该方法的另一次迭代，以递归方式调用。

第二次迭代将执行相同的检查，但是这次它不会将(1,3)作为值，而是将(2,3)作为值。

结果将是最后的第三次迭代，结果将是3，因为(3,3)参数将满足条件a == b。

最后，结果将为a (as 1) + a (as 2) + 3 (as recursion result) = 1+2+3 = 6

Answer 3

看看：Watch and QuickWatch Windows，看看如何在调试器中逐步执行代码，并查看值如何变化。

递归方法的关键在于，它们始终具有某种条件，在这些条件下它们将返回实际值（无需调用自身）。就您而言，就是a == b。递归部分是递增a然后再次调用自身。因此，对方法的第一次调用等待第二次调用返回，而等待第二次调用返回。在第三个调用中，我们满足条件a == b，因此返回一个值，然后堆栈“展开”。

也许该图说明了通过堆栈（某种）的流程会有所帮助。为了避免混淆，我省略了主要逻辑（并在每个步骤中显示了每个变量值），仅包括了调用的return部分：

i = RecursiveMethod(1, 3);
    ┗► return 1 + RecursiveMethod(2, 3);
                  ┗► return 2 + RecursiveMethod(3, 3);
                                ┗► return 3;
                     return 2 + 3 ◄┛
       return 1 + 5 ◄┛
i = 6 ◄┛

请注意，此方法存在致命缺陷，即它假设a小于或等于b。尝试使用a = 3和b = 1调用该方法，由于递归a永远不会满足退出条件a == b，它将递归地调用自身，直到堆栈溢出为止。

Answer 4

我试图通过将递归显示为伪代码中的嵌套调用来可视化该过程：

static int RecursiveMethod(int a(=1), int b(=3))
{
    if (a == b) // FALSE
    {
        return a; // NOT EXECUTED
    }
    else 
    {
        return a(=1)                                                 // ==> RETURNS 1 + 5 = 6
            + RecursiveMethod(int a+1(=2), int b(=3))                                   ^
              {                                                                         |
                  if (a == b) // FALSE                                                  |
                  {                                                                     |
                      return a; // NOT EXECUTED                                         |
                  }                                                                     |
                  else                                                                  |
                  {                                                                     |
                      return a(=2)                               // ==> RETURNS 2 + 3 = 5
                          + RecursiveMethod(int a+1(=3), int b(=3))                 ^
                            {                                                       |
                                if (a == b) // TRUE                                 |
                                {                                                   |
                                    return a;                        // ==> RETURNS 3
                                }
                                else 
                                {
                                    return a + RecursiveMethod(a + 1, b); // NOT EXECUTED
                                }
                            }                                           
                  }
              }                                           
    }
}

首先，递归调用自上而下输入，直到由于a == b而停止递归，然后结果冒泡

递归：显示从a到b的数字，并显示其总和

4 个答案: