在递归函数中返回

Question

我试图了解如何在 C 中使用递归，但我无法理解 return 在其中的工作原理。

请考虑以下代码：

int     recur(int i)
{
    printf("recur: i = %d\n", i);
    if (i < 3)
    {
        recur(i + 1);
        return 10;
    }
    else if (i < 5)
        recur(i + 1);
    return i;
}

int     main(void)
{
    int     i = 0;
    i = recur(i);
    printf("i = %d\n", i);
    return 0;
}

输出是：

recur: i = 0
recur: i = 1
recur: i = 2
recur: i = 3
recur: i = 4
recur: i = 5
i = 10

最后一个返回 return i 是做什么的？这段代码有意义吗？

Answer 1

函数的递归调用不影响返回值。只有在递归函数的第一个实例中遇到的第一个 return 才会将值返回给父函数。遇到任何其他return 只会停止程序当前所在的函数实例。

因此函数在 main 中调用，参数为 0

int     i = 0;
i = recur(i);

第一个遇到的return 位于if 语句中：

if (i < 3)
{
    recur(i + 1);
    return 10;
}

在这种情况下，recur 函数在将值返回给main 之前被调用。它将创建另一个 recur 实例，它会做一些事情，但是在这个 recur 实例结束后，recur 的主实例将继续，在这种情况下，将返回 10 给函数 main .

要知道您的递归函数将返回到main 函数的内容，您可以简单地注释对函数新实例的所有调用：

int     recur(int i)
{
    if (i < 3)
    {
        //recur(i + 1);
        return 10;
    }
    else if (i < 5)
    {
        //recur(i + 1);
    }
    return i;
}

在这种情况下，这是程序将读取的内容：

int     recur(int i)
{
    if (i < 3)
        return 10;
    return i;
}

Answer 2

我认为这是最容易理解的递归函数之一。

int pow(int n, int x)
{
    if (n != 1)
        return pow(n - 1, x * x)
    else 
        return x;
} 

一起学习pow(3, 2) : 2^3 = 2 * 2 * 2 = 8

第一次迭代：pow(3, 2) returns pow(2, 4)
第二次迭代：pow(2, 4) returns pow(1, 8)
第三次迭代：n == 1 所以pow(1, 8) returns x = 8

递归函数在过程的i + 1 步骤返回对自身的调用。为了避免无限循环，你必须让 sur 你有一个 break 条件，这会导致返回一个不同于 self-call 的东西。

Answer 3

您至少得到了一个有助于解释您的代码行为的答案。

我想在这里通过不同的附加途径提供帮助。两者共同为您提供不同的观点。
为此，我提供了一个通过检测增强的代码版本，它可以更详细地告诉您发生了什么。
这使您可以玩代码并观察，这将为您提供真正有用的答案。

注意：

• for(c 行仅用于提示性缩进；
  为此我选择不使用函数，感觉它使有趣的函数调用更加突出
• 我添加了一个参数“嵌套”，它是为了
  • 制作（希望有用的）输出的一部分
  • 说明递归嵌套通常有一些影响
• 我引入了一个局部变量“j”，
  显示在大多数情况下 reutrn 值会发生什么

代码：

#include <stdio.h>

int     recur(int i, int nesting)
{   int c;
    for(c=0;c<nesting;c++) { printf(" ");}
    printf("recur[%d](%i)", nesting, i);
    if (i < 3)
    {   printf("i <3, calling recur[%d](%d)\n", nesting+1, i+1);
        recur(i + 1, nesting+1);
        for(c=0;c<nesting;c++) { printf(" ");}
        printf("returning 10 from recur[%d], with i==%d\n", nesting, i);
        return 10;
    }
    else if (i < 5)
    {
        int j=0;
        printf("i <5, calling recur[%d](%d)\n", nesting+1, i +1);
        j=recur(i + 1, nesting+1);
        for(c=0;c<nesting;c++) { printf(" ");}
        printf("ignored return value from recur[%d](%d) is %d", nesting+1, i+1, j);
    }

    printf("\n");
    for(c=0;c<nesting;c++) { printf(" ");}
    printf("returning i from recur[%d], with i==%d\n", nesting, i);
    return i;
}

int     main(void)
{
    int     i = 0;
    i = recur(i, 0);
    printf("the last return value did not get ignored: i = %d\n", i);
    return 0;
}

输出：

recur[0](0)i <3, calling recur[1](1)
  recur[1](1)i <3, calling recur[2](2)
    recur[2](2)i <3, calling recur[3](3)
      recur[3](3)i <5, calling recur[4](4)
        recur[4](4)i <5, calling recur[5](5)
          recur[5](5)
          returning i from recur[5], with i==5
        ignored return value from recur[5](5) is 5
        returning i from recur[4], with i==4
      ignored return value from recur[4](4) is 4
      returning i from recur[3], with i==3
    returning 10 from recur[2], with i==2
  returning 10 from recur[1], with i==1
returning 10 from recur[0], with i==0
the last return value did not get ignored: i = 10

注意：
recur[n](m) 当然不是 C 语法。
它只是表示使用参数“m”在嵌套级别“n”上调用函数“recur”。
（尤其不要将“[]”与数组混淆，它们不存在。）

Answer 4

return 0 是主函数的返回值，而不是递归代码的返回值。