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

考虑定义如下的函数：

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）循环，而尾部递归在优化为向后跳转时，与循环同构。

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

尾部递归/n/

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

递归意味着函数调用自身。例如：

(define (un-ended name)
  (un-ended 'me)
  (print "How can I get here?"))

尾部递归是指结束函数的递归：

(define (un-ended name)
  (print "hello")
  (un-ended 'me))

看，非终结函数（Scheme术语中的过程）做的最后一件事就是调用自己。另一个（更有用的）例子是：

(define (map lst op)
  (define (helper done left)
    (if (nil? left)
        done
        (helper (cons (op (car left))
                      done)
                (cdr left))))
  (reverse (helper '() lst)))

在helper过程中，如果左边不是nil，最后一件事就是调用自己（AFTER cons something和cdr something）。这基本上就是如何映射列表的。

尾部递归有一个很大的优点，即解释器（或编译器，取决于语言和供应商）可以对其进行优化，并将其转换为相当于while循环的东西。事实上，在Scheme传统中，大多数“for”和“while”循环都是以尾部递归的方式完成的（据我所知，没有for和while）。

尾部递归是函数调用的递归函数自身位于函数的末尾（“尾部”），其中没有计算在递归调用返回后完成。许多编译器优化以将递归调用更改为尾部递归调用或迭代调用。

考虑计算一个数的阶乘的问题。

一种简单的方法是：

  factorial(n):

    if n==0 then 1

    else n*factorial(n-1)

假设你调用阶乘（4）。递归树为：

       factorial(4)
       /        \
      4      factorial(3)
     /             \
    3          factorial(2)
   /                  \
  2                factorial(1)
 /                       \
1                       factorial(0)
                            \
                             1    

上述情况下的最大递归深度为O（n）。

但是，请考虑以下示例：

factAux(m,n):
if n==0  then m;
else     factAux(m*n,n-1);

factTail(n):
   return factAux(1,n);

factTail（4）的递归树为：

factTail(4)
   |
factAux(1,4)
   |
factAux(4,3)
   |
factAux(12,2)
   |
factAux(24,1)
   |
factAux(24,0)
   |
  24

这里，最大递归深度是O（n），但没有一个调用向堆栈添加任何额外变量。因此编译器可以取消堆栈。

简而言之，尾部递归将递归调用作为函数中的最后一条语句，这样就不必等待递归调用。

所以这是一个尾部递归，即N（x-1，p*x）是函数中的最后一个语句，编译器聪明地发现它可以优化为for循环（阶乘）。第二个参数p携带中间乘积值。

function N(x, p) {
   return x == 1 ? p : N(x - 1, p * x);
}

这是编写上述阶乘函数的非尾部递归方式（尽管某些C++编译器可能无论如何都能优化它）。

function N(x) {
   return x == 1 ? 1 : x * N(x - 1);
}

但这不是：

function F(x) {
  if (x == 1) return 0;
  if (x == 2) return 1;
  return F(x - 1) + F(x - 2);
}

我确实写了一篇题为“理解尾部递归——Visual Studio C++——汇编视图”的长文

尾部递归是指递归算法中最后一条逻辑指令中的最后一个递归调用。

通常在递归中，您有一个基本情况，即停止递归调用并开始弹出调用堆栈。使用一个经典的例子，尽管比Lisp更具C语言，阶乘函数说明了尾部递归。递归调用在检查基本情况条件后发生。

factorial(x, fac=1) {
  if (x == 1)
     return fac;
   else
     return factorial(x-1, x*fac);
}

对阶乘的初始调用将是阶乘（n），其中fac=1（默认值），n是要计算阶乘的数字。