递归有两种基本类型：头部递归和尾部递归。

在头部递归中，函数进行递归调用，然后执行更多计算，可能使用例如递归调用。在尾部递归函数中，所有计算首先发生递归调用是最后发生的事情。

摘自这篇超棒的帖子。请考虑阅读它。

这是《计算机程序的结构和解释》中关于尾部递归的摘录。

在对比迭代和递归时，我们必须小心不要将递归过程的概念与递归过程。当我们将过程描述为递归时指过程定义所指的句法事实（直接或间接）到程序本身。但当我们将过程描述为遵循一种模式，即线性递归，我们谈论的是过程如何演变，而不是如何编写过程的语法。这似乎令人不安我们将递归过程（如事实iter）称为生成迭代过程。然而，这个过程实际上是迭代的：它的状态被其三个状态变量完全捕获解释器只需要跟踪三个变量执行该过程。过程和程序之间的区别可能是令人困惑的是，大多数通用语言的实现（包括Ada、Pascal和C） 以这样一种方式设计过程消耗的内存量会随着过程调用，迭代。因此，这些语言可以描述迭代仅通过使用专用的“循环构造”来处理例如do、repeat、until、for和while。实施方案不具有此缺陷。它将在恒定空间中执行迭代过程，即使迭代过程由递归过程描述。一具有此属性的实现称为尾部递归。用一个尾部递归实现，可以使用普通过程调用机制，使特殊迭代构造只作为句法糖有用。

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

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

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

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

为了理解尾部调用递归和非尾部调用递归之间的一些核心区别，我们可以探索这些技术的.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尾部调用条件。

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

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

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

递归函数是一个自己调用的函数

它允许程序员用最少的代码编写高效的程序。

缺点是，如果编写不当，它们可能会导致无限循环和其他意外结果。

我将解释简单递归函数和尾部递归函数

为了编写简单的递归函数

首先要考虑的一点是你应该什么时候决定出来是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