Question

我理解“a”解决方案是：

function Factorial(number)
{
    if(number == 0 || number == 1){
        return 1;
    }

    return number * Factorial(number -1);

}

我想了解到底发生了什么。我理解当数字== 1时，最后一部分的情况一直在发生。

如果我们举一个简单的例子说3！

3不等于0或1所以我们返回3 * Factorial（2）
2不等于0或1所以我们返回2 * Factorial（1）
1等于1所以我们返回1

我们怎么知道何时停止？事实是我们返回1告诉函数停止吗？

如果是这种情况，为什么当我们第一次返回3 * Factorial（2）时函数不会停止？是因为它返回一个函数，所以它必须继续，直到它不再返回一个函数？

谢谢

Answer 1

我认为你必须理解阶乘的逻辑。

因此，因子只是产品，用感叹号表示，即如果你写的话

 0! = 1
 1! = 1
 2! = 2*1
 3! = 3*2*1
 4! = 4*3*2*1
 5! = 5*4*3*2*1

希望您找到该模式，因此您可以将上述因子写为：

 0! = 1
 1! = 1
 2! = 2*1!
 3! = 3*2!
 4! = 4*3!
 5! = 5*4!

所以在你的函数中你使用的是类似的逻辑。

现在你的功能

if(number == 0 || number == 1)
{
   return 1;
}

上述逻辑涵盖了前两种情况，即 0！和 1！和

return number * Factorial(number -1);

是剩下的数字。

所以你正在使用解决阶乘问题的递归技术。

要理解递归，让我们取一个数字说5，即我们要找到5的值！

然后首先你的功能将检查

if(number == 0 || number == 1)

不满意，然后移动到下一行，即

return number * Factorial(number -1);

给出了

5*Factorial(5-1) which is equal to 5*Factorial(4)

现在，在对Factorial函数的后续调用中，它将返回如下值：

5*(4*Factorial(4-1)) which is equal to 5*(4*Factorial(3))
5*(4*(3*Factorial(3-1)) which is equal to 5*(4*(3*Factorial(2)))
5*(4*(3*(2*Factorial(2-1)))) which is equal to 5*(4*(3*(2*Factorial(1))))

现在当它返回factorial（1）然后返回你的条件

if(number == 0 || number == 1)

满意，因此您得到的结果为：

5*4*3*2*1 = 120

旁注：

请注意，factrial仅用于正整数。

Answer 2

递归依赖于所谓的基本情况：

if(number == 0 || number == 1){
    return 1;
}

if语句称为基本案例。基本案例定义递归何时应该停止。请注意您如何返回1而不是再次返回对该函数的调用结果，例如Factorial(number -1)

如果不符合基本情况的条件（即如果number不是1或0），那么您将继续使用number * Factorial(number - 1)再次调用该函数

Answer 3

如果是这种情况，为什么当我们第一次返回3 * Factorial（2）时函数不会停止？

你简单的3个例子！可以这样阐述：

return 3 * Factorial(2)

然后

将替换为

return 3 * (2 * Factorial(1))

然后将被

取代

return 3 * (2 * 1) // = 6 Hence 6 is returned at last and recursion ends.

我们怎么知道何时停止？

当我们停止所有的Factorial（值）被返回的值替换时。

事实上我们返回1告诉函数停止吗？

在某种程度上，是的。因为它是最后返回的值。

Answer 4

它被称为递归。

此功能就像这样调用

var result = Factorial（3）; 在析因函数中

第一次返回3 * Factorial（2）;

现在这里返回语句没有执行insted Factorial再次被调用.. 所以第二次返回2 * Factorial（1）;

再次在Factorial（1）第三次返回1;

所以去第二个返回2 * 1;

首先是旁边返回3 *（2 * 1）;

最后 var result = 3 * 2 * 1 = 6.

Answer 5

该函数正在递归（调用自身） - 每次从“数字”中取一个。

最终（只要它是一个正整数，你可以调用它，否则你可能会得到一个无限循环）你总是会遇到条件（数字== 1）所以不会再进一步递归，它会返回1而不是再次调用该函数。

然后，一旦你触及底部（1），它将开始运行该函数并在函数调用堆栈中以另一种方式返回，每次使用前一个结果：

1 = 1 
(2*1) = 2
(3*2) = 6
(4*6) = 24

等

因此函数的最终return语句将返回所需的结果

你能解释一下这个Factorial函数是如何工作的吗？

5 个答案: