当我开始学习口齿不清时，我遇到了“尾部递归”这个词。这到底是什么意思？
当前回答
递归函数是一个自己调用的函数
它允许程序员用最少的代码编写高效的程序。
缺点是，如果编写不当，它们可能会导致无限循环和其他意外结果。
我将解释简单递归函数和尾部递归函数
为了编写简单的递归函数
首先要考虑的一点是你应该什么时候决定出来是if循环的第二个问题是，如果我们是自己的职能部门，我们应该做什么
从给定的示例中：
public static int fact(int n){
if(n <=1)
return 1;
else
return n * fact(n-1);
}
从上面的例子中
if(n <=1)
return 1;
是何时退出循环的决定因素
else
return n * fact(n-1);
是否要进行实际处理
为了便于理解，让我逐一完成任务。
让我们看看如果我运行事实（4），内部会发生什么
替换n=4
public static int fact(4){
if(4 <=1)
return 1;
else
return 4 * fact(4-1);
}
如果循环失败，则转到else循环因此它返回4*事实（3）
在堆栈内存中，我们有4*事实（3）替换n=3
public static int fact(3){
if(3 <=1)
return 1;
else
return 3 * fact(3-1);
}
如果循环失败，则转到else循环
因此它返回3*事实（2）
记住我们称之为“4*事实”（3）``
事实（3）的输出=3*事实（2）
到目前为止，堆栈具有4*事实（3）=4*3*事实（2）
在堆栈内存中，我们有4*3*事实（2）替换n=2
public static int fact(2){
if(2 <=1)
return 1;
else
return 2 * fact(2-1);
}
如果循环失败，则转到else循环
因此它返回2*事实（1）
记住我们称之为4*3*事实（2）
事实（2）的输出=2*事实（1）
到目前为止，堆栈具有4*3*事实（2）=4*3*2*事实（1）
在堆栈内存中，我们有4*3*2*事实（1）替换n=1
public static int fact(1){
if(1 <=1)
return 1;
else
return 1 * fact(1-1);
}
如果循环为真
所以它返回1
记住我们称之为4*3*2*事实（1）
事实（1）的输出=1
到目前为止，堆栈具有4*3*2*事实（1）=4*3*2*1
最后，事实（4）的结果=4*3*2*1=24
尾部递归将是
public static int fact(x, running_total=1) {
if (x==1) {
return running_total;
} else {
return fact(x-1, running_total*x);
}
}
替换n=4
public static int fact(4, running_total=1) {
if (x==1) {
return running_total;
} else {
return fact(4-1, running_total*4);
}
}
如果循环失败，则转到else循环因此它返回事实（3，4）
在堆栈内存中，我们有事实（3，4）替换n=3
public static int fact(3, running_total=4) {
if (x==1) {
return running_total;
} else {
return fact(3-1, 4*3);
}
}
如果循环失败，则转到else循环
因此它返回事实（2，12）
在堆栈内存中，我们有事实（2，12）替换n=2
public static int fact(2, running_total=12) {
if (x==1) {
return running_total;
} else {
return fact(2-1, 12*2);
}
}
如果循环失败，则转到else循环
因此它返回事实（1，24）
在堆栈内存中，我们有事实（1，24）替换n=1
public static int fact(1, running_total=24) {
if (x==1) {
return running_total;
} else {
return fact(1-1, 24*1);
}
}
如果循环为真
因此它返回running_total
running_total=24的输出
最后，事实（4,1）的结果=24
其他回答
在传统递归中，典型的模型是首先执行递归调用，然后获取递归调用的返回值并计算结果。通过这种方式，在每次递归调用返回之前，您不会得到计算结果。
在尾部递归中，首先执行计算，然后执行递归调用，将当前步骤的结果传递给下一个递归步骤。这导致最后一条语句的形式为（return（递归函数参数））。基本上，任何给定递归步骤的返回值都与下一个递归调用的返回值相同。
这样做的结果是，一旦准备好执行下一个递归步骤，就不再需要当前堆栈帧。这允许进行一些优化。事实上，使用一个适当编写的编译器，您永远不应该有带有尾部递归调用的堆栈溢出窃笑。只需在下一个递归步骤中重用当前堆栈帧。我很确定Lisp会这么做。
尾部递归是指递归算法中最后一条逻辑指令中的最后一个递归调用。
通常在递归中，您有一个基本情况，即停止递归调用并开始弹出调用堆栈。使用一个经典的例子，尽管比Lisp更具C语言，阶乘函数说明了尾部递归。递归调用在检查基本情况条件后发生。
factorial(x, fac=1) {
if (x == 1)
return fac;
else
return factorial(x-1, x*fac);
}
对阶乘的初始调用将是阶乘（n），其中fac=1（默认值），n是要计算阶乘的数字。
考虑一个将前N个自然数相加的简单函数。（例如，和（5）＝0+1+2+3+4+5＝15）。
下面是一个使用递归的简单JavaScript实现：
function recsum(x) {
if (x === 0) {
return 0;
} else {
return x + recsum(x - 1);
}
}
如果调用recsum（5），JavaScript解释器将评估以下内容：
recsum(5)
5 + recsum(4)
5 + (4 + recsum(3))
5 + (4 + (3 + recsum(2)))
5 + (4 + (3 + (2 + recsum(1))))
5 + (4 + (3 + (2 + (1 + recsum(0)))))
5 + (4 + (3 + (2 + (1 + 0))))
5 + (4 + (3 + (2 + 1)))
5 + (4 + (3 + 3))
5 + (4 + 6)
5 + 10
15
请注意，在JavaScript解释器开始实际计算和之前，每个递归调用都必须完成。
下面是同一函数的尾部递归版本：
function tailrecsum(x, running_total = 0) {
if (x === 0) {
return running_total;
} else {
return tailrecsum(x - 1, running_total + x);
}
}
以下是调用tailrecsum（5）时发生的事件序列（由于默认的第二个参数，它实际上是tailrecsum（5，0））。
tailrecsum(5, 0)
tailrecsum(4, 5)
tailrecsum(3, 9)
tailrecsum(2, 12)
tailrecsum(1, 14)
tailrecsum(0, 15)
15
在尾部递归情况下，每次对递归调用求值时，running_total都会更新。
注：原始答案使用了Python中的示例。由于Python解释器不支持尾部调用优化，这些代码已更改为JavaScript。然而，虽然尾部调用优化是ECMAScript 2015规范的一部分，但大多数JavaScript解释器不支持它。
递归函数是一个自己调用的函数
它允许程序员用最少的代码编写高效的程序。
缺点是，如果编写不当，它们可能会导致无限循环和其他意外结果。
我将解释简单递归函数和尾部递归函数
为了编写简单的递归函数
首先要考虑的一点是你应该什么时候决定出来是if循环的第二个问题是，如果我们是自己的职能部门，我们应该做什么
从给定的示例中：
public static int fact(int n){
if(n <=1)
return 1;
else
return n * fact(n-1);
}
从上面的例子中
if(n <=1)
return 1;
是何时退出循环的决定因素
else
return n * fact(n-1);
是否要进行实际处理
为了便于理解，让我逐一完成任务。
让我们看看如果我运行事实（4），内部会发生什么
替换n=4
public static int fact(4){
if(4 <=1)
return 1;
else
return 4 * fact(4-1);
}
如果循环失败，则转到else循环因此它返回4*事实（3）
在堆栈内存中，我们有4*事实（3）替换n=3
public static int fact(3){
if(3 <=1)
return 1;
else
return 3 * fact(3-1);
}
如果循环失败，则转到else循环
因此它返回3*事实（2）
记住我们称之为“4*事实”（3）``
事实（3）的输出=3*事实（2）
到目前为止，堆栈具有4*事实（3）=4*3*事实（2）
在堆栈内存中，我们有4*3*事实（2）替换n=2
public static int fact(2){
if(2 <=1)
return 1;
else
return 2 * fact(2-1);
}
如果循环失败，则转到else循环
因此它返回2*事实（1）
记住我们称之为4*3*事实（2）
事实（2）的输出=2*事实（1）
到目前为止，堆栈具有4*3*事实（2）=4*3*2*事实（1）
在堆栈内存中，我们有4*3*2*事实（1）替换n=1
public static int fact(1){
if(1 <=1)
return 1;
else
return 1 * fact(1-1);
}
如果循环为真
所以它返回1
记住我们称之为4*3*2*事实（1）
事实（1）的输出=1
到目前为止，堆栈具有4*3*2*事实（1）=4*3*2*1
最后，事实（4）的结果=4*3*2*1=24
尾部递归将是
public static int fact(x, running_total=1) {
if (x==1) {
return running_total;
} else {
return fact(x-1, running_total*x);
}
}
替换n=4
public static int fact(4, running_total=1) {
if (x==1) {
return running_total;
} else {
return fact(4-1, running_total*4);
}
}
如果循环失败，则转到else循环因此它返回事实（3，4）
在堆栈内存中，我们有事实（3，4）替换n=3
public static int fact(3, running_total=4) {
if (x==1) {
return running_total;
} else {
return fact(3-1, 4*3);
}
}
如果循环失败，则转到else循环
因此它返回事实（2，12）
在堆栈内存中，我们有事实（2，12）替换n=2
public static int fact(2, running_total=12) {
if (x==1) {
return running_total;
} else {
return fact(2-1, 12*2);
}
}
如果循环失败，则转到else循环
因此它返回事实（1，24）
在堆栈内存中，我们有事实（1，24）替换n=1
public static int fact(1, running_total=24) {
if (x==1) {
return running_total;
} else {
return fact(1-1, 24*1);
}
}
如果循环为真
因此它返回running_total
running_total=24的输出
最后，事实（4,1）的结果=24
为了理解尾部调用递归和非尾部调用递归之间的一些核心区别，我们可以探索这些技术的.NET实现。
这是一篇包含C#、F#和C++\CLI中的一些示例的文章：C#、F#和C++/CLI中的尾部递归冒险。
C#没有针对尾部调用递归进行优化，而F#进行了优化。
原理的差异涉及循环与Lambda演算。C#的设计考虑到了循环，而F#是基于Lambda演算的原理构建的。有关Lambda微积分原理的一本非常好（免费）的书，请参阅Abelson、Sussman和Sussman的《计算机程序的结构和解释》。
关于F#中的尾部调用，有关非常好的介绍性文章，请参阅F#中尾部调用的详细介绍。最后，这里有一篇文章介绍了非尾部递归和尾部调用递归（在F#中）之间的区别：尾部递归与F sharp中的非尾部递归。
如果您想了解C#和F#之间尾部调用递归的一些设计差异，请参阅在C#和F#中生成尾部调用操作码。
如果您非常想知道哪些条件阻止C#编译器执行尾部调用优化，请参阅本文：JIT CLR尾部调用条件。
