函数调用栈（Function Call Stack）是计算机内存中用于跟踪函数调用和返回的一种数据结构。在程序执行期间，每当一个函数被调用时，相关的信息（例如函数参数、局部变量和返回地址）都会被存储在栈内存中。当函数执行完毕并返回时，这些信息会被弹出栈，控制流程回到调用该函数的地方。

具体来说，每次函数调用时，以下步骤会发生：

1. 被调用函数的参数被压入栈中。
2. 被调用函数的返回地址（即调用该函数的下一条指令的地址）也被压入栈中。
3. 控制转移到被调用函数的代码中，开始执行。
4. 在被调用函数中，可能会有更多的函数调用，这些调用会在栈中嵌套存储。
5. 当一个函数执行完毕并返回时，它的返回值会被存储到指定的寄存器或者内存位置中，然后栈中的数据被弹出，控制流程回到调用该函数的地方。

这样，函数调用栈的结构就形成了一个“后进先出”（LIFO）的堆栈结构，最后被调用的函数最先返回，直到最初的调用者函数。

函数调用栈在程序执行期间起着至关重要的作用，它不仅跟踪了函数调用的顺序，还管理了函数调用过程中的各种数据。当栈空间不足或者发生溢出时，就会导致栈溢出错误，这通常是由于递归调用层次过深或者函数调用过程中分配的局部变量过多所致。
----------
 

理解递归的过程涉及到函数调用栈的概念，也就是说，在每次递归调用时，函数的参数、局部变量等信息都会被存储在内存中的一个栈结构中。让我们来详细解释一下递归函数在压栈和弹栈过程中的具体操作。

1. **压栈（Push）：** 当一个函数被调用时，系统会为该函数分配一块内存空间，用于存储函数的参数、局部变量以及函数执行过程中的其他信息。这个内存空间被称为栈帧（Stack Frame）。栈帧包含了函数调用所需的所有信息。在递归调用中，每次函数调用都会创建一个新的栈帧，并将其压入函数调用栈中。

2. **执行函数体：** 一旦函数被调用，系统就会开始执行函数体内的代码。在递归函数中，通常会包含一个基本情况（base case），用于结束递归调用。如果基本情况未达到，函数会继续递归调用自身，每次调用都会创建一个新的栈帧。

3. **递归调用：** 在函数体内部，如果遇到递归调用，系统会暂时停止当前函数的执行，转而执行被调用的函数。这时，新的函数调用会在栈中创建一个新的栈帧，并继续执行相应的函数体。

4. **弹栈（Pop）：** 当函数执行结束时，系统会从栈顶弹出当前函数的栈帧，将控制权返回给上一级函数。这意味着上一级函数可以继续执行它之前被中断的部分。如果递归调用嵌套了多层，那么每个函数执行完毕后都会被弹出栈，直到回到最初的调用位置。

这样，递归函数的压栈和弹栈过程就完成了一次完整的递归调用。通过不断地压栈、执行函数体、递归调用和弹栈，递归函数可以解决问题并得到结果。

在递归调用中，每次递归返回的结果会依次相乘，直到达到基线条件，然后将这些结果相乘得到最终的阶乘值。让我们用一个简单的例子来说明这个过程：

以计算 5 的阶乘（5!）为例：

1. 调用 `factorial(5)`，这将导致函数内部调用 `factorial(4)` 并将结果乘以 5。
2. 在 `factorial(4)` 中，又会调用 `factorial(3)` 并将结果乘以 4。
3. 在 `factorial(3)` 中，又会调用 `factorial(2)` 并将结果乘以 3。
4. 在 `factorial(2)` 中，又会调用 `factorial(1)` 并将结果乘以 2。
5. 在 `factorial(1)` 中，由于 `n` 等于 1，满足基线条件，直接返回 1。

然后，递归开始回溯。每次返回时，将上一级递归调用的结果乘以当前的 `n` 值：

- `factorial(1)` 返回 1
- `factorial(2)` 返回 2 * 1 = 2
- `factorial(3)` 返回 3 * 2 = 6
- `factorial(4)` 返回 4 * 6 = 24
- `factorial(5)` 返回 5 * 24 = 120

所以，5 的阶乘为 120。这就是递归过程中依次返回结果进行相乘的简要描述。

-----------

让我用更简单的方式来解释一下递归。

想象你有一套小人积木，每个积木上都写着一个数字。现在，你想要计算所有积木上数字的总和。但是，这些积木是堆叠在一起的，你不能直接看到每个积木上的数字。

现在，你该怎么做呢？一种方法是逐个拿掉积木，看看上面的数字，然后加起来。但是，这会很麻烦，因为积木很多。

另一种方法是：你拿掉最上面的一个积木，看看上面的数字，然后把剩下的积木当作一个整体，再次进行相同的操作。你继续这样做，直到所有积木都被拿掉为止。

这种方法就是递归。你不断地重复相同的操作，直到达到了某个特定的条件（比如没有积木了），然后逐层返回结果。

在这个例子中，拿掉最上面的积木并查看上面的数字，就相当于计算了一个阶乘的一部分。而把剩下的积木当作一个整体并进行相同操作，就相当于用递归的方式计算剩余部分的阶乘。

----------
进一步解释。

想象一下，当你在程序中调用一个函数时，比如说你有一个函数 `foo()` 调用了另一个函数 `bar()`，而 `bar()` 又调用了另一个函数 `baz()`。这时候，函数调用栈就会起作用。

1. 当你调用 `foo()` 时，当前的执行状态（包括变量、执行指针等）会被保存到栈中，并且控制流会转移到 `foo()` 的代码中。
2. 当 `foo()` 调用 `bar()` 时，`bar()` 的参数和返回地址会被压入栈中，然后控制流程会转移到 `bar()` 的代码中。
3. 同样地，当 `bar()` 调用 `baz()` 时，`baz()` 的参数和返回地址也会被压入栈中，然后控制流程会转移到 `baz()` 的代码中。

这样，调用栈就像一个记录函数调用和返回的历史记录表。当 `baz()` 执行完成并返回时，它的数据会被弹出栈，控制流程会返回到 `bar()`，然后再弹出 `bar()` 的数据，最后返回到 `foo()`。

函数调用栈的大小是有限的，当函数嵌套调用过深或者使用递归的时候，如果栈空间不足，就会导致栈溢出错误。这就是为什么编程中需要小心处理递归调用或者深度嵌套函数的原因之一。