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步骤返回对自身的调用。为了避免无限循环，你必须让你有一个休息条件，这会导致返回不同于自我呼唤的东西。

Answer 3

您至少有一个答案可以帮助您解释代码的行为。

我想通过其他不同的路径提供帮助。两者一起为您提供不同的观点为此，我提供了一个由仪器增强的代码版本，它更详细地告诉您发生了什么这使您可以使用代码并观察，这将为您提供真正有用的答案。

注意：

for(c行仅用于暗示缩进;
我选择不使用函数，感觉它使有趣的函数调用更加突出
我添加了一个参数＆＃34;嵌套＆＃34;，它是为了
- 制作（希望有用）输出的一部分
- 表明通常递归嵌套有一些影响
我介绍了一个局部变量＆＃34; j＆＃34;，
显示大多数情况下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语法它只是表示对函数的调用＆＃34; recur＆＃34;在筑巢水平＆＃34; n＆＃34;参数＆＃34; m＆＃34;。
（特别是不要将＆＃34; []＆＃34;与数组混淆，它们不存在。）

Answer 4

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

返回递归函数

4 个答案: