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

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

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

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

尾部递归/n/

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

重要的一点是尾部递归本质上等同于循环。这不仅仅是一个编译器优化的问题，而是一个关于表现力的基本事实。这是双向的：你可以采取任何形式的循环

while(E) { S }; return Q

其中E和Q是表达式，S是语句序列，并将其转换为尾部递归函数

f() = if E then { S; return f() } else { return Q }

当然，必须定义E、S和Q来计算一些变量的有趣值。例如，循环函数

sum(n) {
  int i = 1, k = 0;
  while( i <= n ) {
    k += i;
    ++i;
  }
  return k;
}

等效于尾部递归函数

sum_aux(n,i,k) {
  if( i <= n ) {
    return sum_aux(n,i+1,k+i);
  } else {
    return k;
  }
}

sum(n) {
  return sum_aux(n,1,0);
}

（用参数较少的函数“包装”尾部递归函数是一种常见的函数习惯用法。）

下面是一个使用尾部递归进行阶乘的常见Lisp示例。由于无堆栈的性质，人们可以进行疯狂的大型阶乘计算。。。

(defun ! (n &optional (product 1))
    (if (zerop n) product
        (! (1- n) (* product n))))

然后为了好玩，你可以尝试（格式化nil“~R”（！25））

如果每个递归情况仅由对函数本身的调用组成，并且可能具有不同的参数，则函数是尾部递归的。或者，尾部递归是没有待定工作的递归。注意，这是一个与编程语言无关的概念。

考虑定义如下的函数：

g(a, b, n) = a * b^n

一种可能的尾部递归公式是：

g(a, b, n) | n is zero = a
           | n is odd  = g(a*b, b,   n-1)
           | otherwise = g(a,   b*b, n/2)

如果您检查g（…）的每一个涉及递归情况的RHS，您会发现整个RHS都是对g（……）的调用，仅此而已。这个定义是尾部递归的。

作为比较，非尾部递归公式可能是：

g'(a, b, n) = a * f(b, n)
f(b, n) | n is zero = 1
        | n is odd  = f(b, n-1) * b
        | otherwise = f(b, n/2) ^ 2

f（…）中的每个递归情况都有一些需要在递归调用之后进行的未决工作。

注意，当我们从“g”到“g”时，我们充分利用了关联性（和交换性）乘法。这并不是偶然的，在大多数需要将递归转换为尾递归的情况下，都会利用这些财产：如果我们想急切地做一些工作，而不是让它等待，我们必须使用关联性之类的东西来证明答案是一样的。

尾部递归调用可以通过向后跳转来实现，而不是使用堆栈进行常规递归调用。注意，检测尾部呼叫或发出向后跳转通常很简单。然而，通常很难重新排列参数，以便向后跳转。由于此优化不是免费的，语言实现可以选择不实现此优化，或者通过使用“tailcall”指令标记递归调用和/或选择更高的优化设置来要求选择加入。

然而，某些语言（例如Scheme）确实需要所有实现来优化尾部递归函数，甚至可能需要所有尾部位置的调用。

在大多数命令式语言中，向后跳转通常被抽象为（while）循环，而尾部递归在优化为向后跳转时，与循环同构。

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

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