一、递归调用（Recursive Call）
定义：函数在执行过程中直接或间接调用自身的一种编程技巧。
核心特点：
自相似性：将大问题分解为结构相似的子问题
递归出口：必须存在终止条件（Base Case）
栈空间使用：每次调用在内存栈中创建新副本
典型结构：
返回类型 函数名(参数) {
if (终止条件成立) // 递归出口
return 简单解;
else
return 函数名(缩小规模的参数); // 递归调用
}示例1：阶乘计算
int factorial(int n) {
if (n <= 1) // 终止条件
return 1;
else
return n * factorial(n-1); // 递归调用
}
// factorial(5) = 5 * factorial(4) = ... = 120示例2：年龄推算
int age(int n) {
if (n == 1) // 终止条件
return 10;
else
return age(n-1) + 2; // 递归调用
}
// age(5) = age(4)+2 = ... = 18内存图解：
| factorial(1) | → 返回1
| factorial(2) | → 2*factorial(1)
| factorial(3) | → 3*factorial(2)
| factorial(4) | → 4*factorial(3)
| factorial(5) | → 5*factorial(4)
----------------
调用栈（后进先出）适用场景：
问题可分解为相似子问题（树遍历、分治算法）
数学定义递归（斐波那契数列、汉诺塔）
数据结构递归（链表、二叉树操作）
注意事项：
必须有递归出口，否则无限递归导致栈溢出
递归层数不宜过深（栈空间有限）
效率较低（函数调用开销大）
二、嵌套调用（Nested Call）
定义：在调用一个函数的过程中调用其他函数，形成多层调用关系。
核心特点：
函数协作：不同函数分工完成复合任务
非自调用：调用的是其他独立函数
层次结构：形成调用链（A → B → C）
典型结构：
void funcA() {
funcB(); // 嵌套调用B
}
void funcB() {
funcC(); // 嵌套调用C
}
void funcC() {
// 执行具体操作
}文档示例：
int func2(int a, int b) { // 被嵌套函数
return a + b;
}
int func1(int a, int b) { // 嵌套调用func2
return func2(a, b) + 2;
}
int main() {
printf("%d", func1(4, 3)); // 输出9
}执行流程：
main()
↓ 调用
func1(4, 3)
↓ 调用
func2(4, 3) → 返回7
↑
func1获得7 → 返回7+2=9
↑
main输出9内存图解：
| func2() 执行 | → 返回结果
| func1() 等待 | → 接收结果继续执行
| main() 等待 | → 接收最终结果
----------------
调用栈适用场景：
模块化编程（每个函数独立功能）
代码复用（如数学函数库调用）
复杂任务分解（主函数→处理函数→工具函数）
优势：
提升代码可读性和可维护性
避免代码重复（DRY原则）
便于团队协作开发
关键对比表
| 特性 | 递归调用 | 嵌套调用 |
|---|---|---|
| 调用对象 | 自身 | 其他函数 |
| 核心目的 | 解决自相似问题 | 实现功能分解 |
| 内存消耗 | 高（栈空间累积） | 低（单次调用释放） |
| 终止条件 | 必须显式存在 | 不需要特定终止条件 |
| 执行效率 | 较低（调用开销大） | 较高 |
| 典型应用 | 阶乘/斐波那契/树遍历 | 模块化程序/分层架构 |
| 代码结构 | 简洁但抽象 | 直观易理解 |
| 风险 | 栈溢出（无限递归） | 循环依赖（A→B→A） |
混合使用场景
示例：递归+嵌套调用
void printBinary(int n) {
if (n > 1)
printBinary(n/2); // 递归调用
printf("%d", n%2); // 嵌套调用printf
}
// printBinary(13) 输出 1101关键理解：递归关注问题分解的纵向深度，嵌套关注功能协作的横向广度。实际开发中常组合使用。