递归的底层机制

编程语言中，我们习惯将函数（方法）调用自身的过程称为递归，调用自身的函数称为递归函数，用递归方式解决问题的算法称为递归算法。

函数（方法）调用自身的实现方式有 2 种，分别是：

1. 直接调用自身，例如：
   int funciton(/…/) {
   //…
   //调用自身
   function(/…/);
   //…
   }
2. 间接调用自身，例如：
   int funciton1(/…/) {
   //…
   //调用另一个函数
   function2(/…/);
   //…
   }
   int function2(/…/) {
   //…
   //调用function1()函数
   funciton1(/…/);
   //…
   }
   程序中，function1() 函数内部调用了 function2() 函数，而 function2() 函数内部又调用了 function1() 函数。也就是说，function1() 函数间接调用了自身。

设计递归函数时，我们必须为它设置一个结束递归的“出口”，否则函数会一直调用自身（死循环），直至运行崩溃。接下来我们以“用递归方式求 n! ”为例，给大家展示一个正确的递归函数。

n! 指的是求 123*…*n 的值，如下 C 语言程序中的 factorial() 就是实现求 n! 的递归函数：
#include <stdio.h>
int factorial(int n) {
//递归的出口
if (n == 1 || n == 0) {
return 1;
}
//函数调用自身
return n * factorial(n - 1);
}
int main()
{
int n;
scanf(“%d”, &n);
printf(“%d! = %d”, n,factorial(n));
return 0;
}
除非变量 n 的值为 1 或者 0，否则 factorial() 函数会一直调用自身。

假设输入 n 的值为 4，梳理一下 factorial() 函数的执行过程：
调用 factorial(4) 时，由于形参 n 的值为 4，不等于 0 或 1，所以执行 4 * factorial(3) 并返回它的值。为了求出这个表达式的值，必须先执行 factorial(3) 并得到它的返回值，所以编译器转而求 factorial(3) 的值，4 * factorial(3) 的求值被搁置，等待后续再计算；
调用 factorial(3) 时，由于形参 n 的值为 3，不等于 0 或 1，所以执行 3 * factorial(2) 并返回它的值。为了求出这个表达式的值，必须先执行 factorial(2) 并得到它的返回值，所以编译器转而求 factorial(2) 的值，3factorial(2) 的求值被搁置，等待后续再计算；
调用 factorial(2) 时，由于形参 n 的值为 2，不等于 0 或 1，所以执行 2 * factorial(1) 并返回它的值。为了求出这个表达式的值，必须先执行 factorial(1) 并得到它的返回值，所以编译器转而求 factorial(1) 的值，2 * factorial(1) 的求值被搁置，等待后续再计算；
调用 factorial(1) 时，由于形参 n 的值为 1，函数的返回值为 1。
知道了 factorial(1) 的返回值为 1，先前被搁置的 2factorial(1) 的值就可以计算出来，因此 factorial(2) 的返回值为 2；
知道了 factorial(2) 的返回值为 2，先前被搁置的 3factorial(2) 的值就可以计算出来，因此 factorial(3) 的返回值为 6；
知道了 factorial(3) 的返回值为 6，先前被搁置的 4factorial(3) 的值就可以计算出来，因此 factorial(4) 的返回值为 24；

程序的执行结果为：
4
4! = 24

递归的底层实现机制
为了方便讲解，当一个函数直接或间接调用自身时，我们将这个函数称作调用者，将直接或间接调用的自身称作被调用者。

递归函数执行时，调用者会将执行代码的权力移交给被调用者，同时还可能会向被调用者传输一些数据。此后，调用者将暂停执行，直至被调用者执行完成并将执行代码的权力交换给调用者后，它才能继续执行。

例如在求 n! 的递归函数中，factorial(n) 是调用者，函数内部的 factorial(n-1) 是被调用者。当 n 的值不为 1 和 0 时，调用者会将执行代码的权值移交给被调用者，同时会将 n-1 的值传递给被调用者。此后，factorial(n) 会暂停执行，直至 factorial(n-1) 执行完毕后，factorial(n) 才能继续执行。

为了确保调用者能够从暂停状态继续执行，当发生递归调用时，多数编程语言都使用栈结构保存调用者的状态信息，包括暂停时局部变量的值、寄存器中保存的数据等等。

图 1 展示了函数递归调用的底层实现过程：

图 1 递归的底层实现

如图 1 所示，F(n) 调用了 F(n-1)，因此 F(n) 会暂停执行，将执行代码的权力移交给 F(n-1)，F(n) 的暂停状态也会入栈保存；同样的道理，F(n-1) 中调用了 F(n-2)，所以 F(n-1) 暂停执行，暂停状态入栈保存，执行代码的权力移交给 F(n-2)…直至递归停止，执行代码的权力会移交给栈中最顶部的函数，该函数的暂停状态信息会从栈中取出并恢复，该函数继续执行，执行完成后再将执行权力移交给栈顶的函数。直至 F(n) 出栈并执行完成，整个递归过程才算完成。

原文链接http://c.biancheng.net/algorithm/recursion.html