使用常规递归，每个递归调用将另一个条目推送到调用堆栈中。递归完成后，应用程序必须将每个条目向下弹出。

使用尾部递归，根据语言的不同，编译器可以将堆栈折叠为一个条目，这样可以节省堆栈空间。。。大型递归查询实际上会导致堆栈溢出。

基本上，尾部递归可以优化到迭代中。

这意味着不需要将指令指针推到堆栈上，只需跳到递归函数的顶部并继续执行即可。这允许函数无限递归而不会溢出堆栈。

我写了一篇关于这个主题的博客文章，里面有堆栈框架的图形示例。

尾部递归函数是一个递归函数，其中递归调用是函数中最后执行的事情。

常规递归函数，我们有堆栈，每次调用递归函数中的递归函数时，都会向调用堆栈添加另一层。在正常递归中空间：O（n）尾递归使空间复杂性从

O(N)=>O(1)

尾部调用优化意味着可以从另一个函数调用函数，而不增加调用堆栈。我们应该在递归解中编写尾部递归。但某些语言实际上不支持其引擎中的尾部递归，该引擎将语言向下编译。自从ecma6以来，规范中就有了尾部递归。但编译js的引擎都没有实现尾部递归。你无法在js中实现O（1），因为编译器本身不知道如何实现这种尾部递归。截至2020年1月1日，Safari是唯一支持尾部呼叫优化的浏览器。Haskell和Java具有尾部递归优化

正则递归阶乘

function Factorial(x) {
  //Base case x<=1
  if (x <= 1) {
    return 1;
  } else {
    // x is waiting for the return value of Factorial(x-1)
    // the last thing we do is NOT applying the recursive call
    // after recursive call we still have to multiply.
    return x * Factorial(x - 1);
  }
}

我们的调用堆栈中有4个调用。

Factorial(4); // waiting in the memory for Factorial(3)
4 * Factorial(3); //  waiting in the memory for Factorial(2)
4 * (3 * Factorial(2)); //  waiting in the memory for Factorial(1)
4 * (3 * (2 * Factorial(1)));
4 * (3 * (2 * 1));

我们正在进行4次Factorial（）调用，空间为O（n）这可能会导致堆栈溢出

尾部递归因子

function tailFactorial(x, totalSoFar = 1) {
  //Base Case: x===0. In recursion there must be base case. Otherwise they will never stop
  if (x === 0) {
    return totalSoFar;
  } else {
    // there is nothing waiting for tailFactorial to complete. we are returning another instance of tailFactorial()
    // we are not doing any additional computaion with what we get back from this recursive call
    return tailFactorial(x - 1, totalSoFar * x);
  }
}

在进行递归调用后，我们不需要记住任何内容

尾部递归函数是一个递归函数，它在返回之前执行的最后一个操作是调用递归函数。也就是说，递归函数调用的返回值将立即返回。例如，您的代码如下所示：

def recursiveFunction(some_params):
    # some code here
    return recursiveFunction(some_args)
    # no code after the return statement

实现尾部调用优化或尾部调用消除的编译器和解释器可以优化递归代码以防止堆栈溢出。如果您的编译器或解释器没有实现尾部调用优化（例如CPython解释器），那么用这种方式编写代码不会有额外的好处。

例如，这是Python中的标准递归阶乘函数：

def factorial(number):
    if number == 1:
        # BASE CASE
        return 1
    else:
        # RECURSIVE CASE
        # Note that `number *` happens *after* the recursive call.
        # This means that this is *not* tail call recursion.
        return number * factorial(number - 1)

这是阶乘函数的尾调用递归版本：

def factorial(number, accumulator=1):
    if number == 0:
        # BASE CASE
        return accumulator
    else:
        # RECURSIVE CASE
        # There's no code after the recursive call.
        # This is tail call recursion:
        return factorial(number - 1, number * accumulator)
print(factorial(5))

（请注意，即使这是Python代码，CPython解释器也不会进行尾部调用优化，因此这样安排代码不会带来运行时的好处。）

您可能需要使代码更不可读，才能利用尾部调用优化，如阶乘示例所示。（例如，基本情况现在有点不直观，累加器参数被有效地用作一种全局变量。）

但尾部调用优化的好处是它可以防止堆栈溢出错误。（我会注意到，通过使用迭代算法而不是递归算法，您可以获得同样的好处。）

当调用堆栈推送了太多帧对象时，会导致堆栈溢出。当调用函数时，框架对象被推到调用堆栈上，当函数返回时，框架将从调用堆栈中弹出。框架对象包含诸如局部变量以及函数返回时要返回的代码行之类的信息。

如果递归函数进行了太多递归调用而没有返回，则调用堆栈可能会超出其帧对象限制。（数量因平台而异；在Python中默认为1000个帧对象。）这会导致堆栈溢出错误。（嘿，这就是这个网站的名字来源！）

但是，如果递归函数做的最后一件事是进行递归调用并返回其返回值，那么它就没有理由保持当前帧对象需要停留在调用堆栈上。毕竟，如果递归函数调用后没有代码，就没有理由挂起当前帧对象的局部变量。因此，我们可以立即删除当前帧对象，而不是将其保留在调用堆栈中。这样做的最终结果是，调用堆栈的大小不会增加，因此不会出现堆栈溢出。

编译器或解释器必须具有尾部调用优化功能，以便能够识别何时可以应用尾部调用优化。即使如此，您可能已经重新排列了递归函数中的代码，以利用尾部调用优化，这取决于您是否值得优化可读性的潜在降低。

尾部递归是你现在的生活。您不断重复使用相同的堆栈帧，因为没有理由或方法返回到“先前”帧。过去已经结束，可以抛弃。你得到一帧，永远走向未来，直到你的过程不可避免地消亡。

当您考虑到某些进程可能会使用额外的帧，但如果堆栈没有无限增长，则仍然被认为是尾部递归时，这种类比就失败了。

术语文件对尾部递归的定义有这样的说法：

尾部递归/n/

如果您还没有厌倦它，请参阅尾部递归。