在递归中，一个值是反向计算的，直到定义了答案为止。从这一点开始，定义被用来计算未来，评估依赖于这个基本条件的其他定义。

递归函数必须有一个停止递归的测试。如果递归函数的当前状态与基本条件匹配，则递归应该停止。否则，应该继续进行递归。

如果您没有注意到反向命名方案，这是阶乘函数的定义。如果传递的是负数，则不调用该函数。如果传递0或1，则返回1。0或1是基本条件。如果该数字大于1，则对lairotcaf ()将启动，直到达到基本条件。

一次lairotcaf (5)展开后，我们有:

这个函数方程是递归方法，这意味着它调用自身。跟踪递归方法最简单的方法是首先注意它的停止情况。为此，它是:

如果(a <= 5) {

返回12;

｝

在本例中，对于任何小于或等于5的值，它返回12。现在，开始跟踪:

式(8)=式(6)*式(7)

式(7)=式(5)*式(6)

式(6)=式(4)*式(5)

因此，式(6)为

12 * 12或144

因此，我们知道:

式(7)= 12 * 144 = 1728

式(8)= 144 * 1728 = 248832

回想一下，递归函数调用自身。因此，仅凭它们在本质上不是递归的事实，您就可以排除几个答案。(事实上，有循环的计算是正确的。)现在，你可以这样考虑阶乘:

然后……

等等。

因此，你在1处有一个停止的情况，它等于1。对于任何其他值，您将返回一个递归值，即参数一个然后factorial方法调用witha - 1．

的喷火方法显然是递归的。因此，让我们看看我们的条件:

如果年代是＂＂，然后代码到达基本情况(在最后):返回";

现在，对于其他字符串，嵌入了两种情况:

c> =“一个”& &c< =“Z”而且c> =“一个”& &c< =“z”

请注意,c字符串的第一个字符。对于这两种情况，如果第一个字符是大写的，函数就把它变成小写的，如果它是小写的，函数就把它变成大写的。然后，它对自己进行递归调用，使用第一个字符之后的字符串剩余部分。如果这两个都没有到达，它只调用自己，忽略第一个字符。因此，这段代码将“翻转”字母字符的任何大小写，但将忽略所有其他字符。这就是为什么正确答案是压缩后的字符串:tHISISMYFAVORITEyAYFORPROGRAMMING

回想一下，递归方法是一个调用自身的方法，慢慢地朝着它终止的“基本情况”工作。因此，您可以立即消除具有迭代循环的选项。这不是递归。

接下来，有两个方法有返回值:

1. 返回int .get(0) + val(int。分表(ints.size ()));
2. 返回int .get(0) + val(int - 1);

这两种方法都行不通，因为它们永远不会终止。(好吧，它们会终止，但只会报错!)另外，第二个是毫无意义的——你不能从一个列表中减去1 !

最后，考虑具有递归返回值的选项:

返回int .remove(0) + val(int);

这实际上会正确地添加项目。然而，通过从列表中删除项目，您将在添加它们的过程中破坏列表!因此，剩下的选项是这个问题的最佳选项:

public static int val(List int) {

If (int .size() == 0) {

返回0;

}其他{

返回int .get(0) + val(int。分表(ints.size ()));

｝

｝

这个函数喷火是递归的，意思是它调用自己。因此，您应该从寻找它的终止点开始。根据上面的定义，当b <= 1或b <= a时，它将终止。在这两种情况下，它将返回1。

现在，让我们对调用进行跟踪:

Foo (5,9) = (9-5) * Foo (5,8) = 4 * Foo (5,8)

Foo (5,8) = (8-5) * Foo (5,7) = 3 * Foo (5,7)

Foo (5,7) = (7-5) * Foo (5,6) = 2 * Foo (5,6)

Foo (5,6) = (6-5) * Foo (5,5) = 1 * Foo (5,5)

Foo (5,5) = 1

因此，仔细追溯，我们得到:

Foo (5,9) = 4 * 3 * 2 * 1 * 1 = 24

的喷火方法是递归的，因此需要首先找到停止的情况。这发生在a <= 3时。此时，该方法返回1。现在，基于这个事实，我们可以开始跟踪方法:

Foo (8) = 8 * Foo (5) * Foo (4)

Foo (5) = 5 * Foo (3) * Foo (1)

Foo (4) = 4 * Foo (1) * Foo (0)

Foo (0) = Foo (1) = Foo (3) = 1

因此，我们知道:

Foo (8) = 8 * 5 * 1 * 1 * 4 * 1 * 1 = 160

这将创建一个无限循环，因为永远不会达到结束循环的条件。由于count永远不等于0,count会不断地被输入到repeat中，没有结束。

数字10输入到recurs并打印count，从count减去2，然后输入到recurs。

因此，第一次迭代得到，10。

第二次迭代得到，10,8。

这样写是因为它把8放在第一次迭代的值之后。

继续这样下去，我们得到，

10 8 6 4 2。

当count达到0时，什么也不打印。

4将被打印出来，因为阶乘(2)= 2。加上阶乘(2)+ 2 = 4。也可以写成2!+ 2 != 4。

N在第一次分配时是2

N被赋值给factorial(2) = 2

N被赋值为N(2) +阶乘(2)= 2所以2+2 = 4

打印出来的时候N是4