《 C++ 点滴漫谈： 三十一 》写好递归不踩坑：C++ 递归函数的精髓与实战

摘要

递归是 C++ 语言中至关重要的编程技术，广泛应用于数据结构、算法设计和数学计算等领域。本文系统讲解了递归的基本概念、分类及其工作原理，并分析了常见应用，如二分查找、快速排序和深度优先搜索。同时，针对递归的性能问题，我们探讨了优化策略，包括尾递归优化、记忆化搜索和动态规划等。此外，文章介绍了 C++11 及以后的现代特性，如 constexpr 递归、std::function 与递归 lambda 以及 C++20 的 concepts 对递归的影响。最后，我们总结了递归的最佳实践，帮助开发者编写更加高效、可维护的 C++ 代码，为递归的深入学习和应用提供指导。

1、引言

在计算机科学中，递归（Recursion） 是一种至关重要的编程思想。它允许函数直接或间接地调用自身，从而将复杂的问题分解为更小的子问题，并以相同的方式求解。递归广泛应用于数学计算、数据结构、算法设计、人工智能等多个领域，是编程人员必须掌握的重要概念之一。

什么是递归？

递归的核心思想是 “自我调用”，即一个函数在其执行过程中直接或间接地调用自身。例如，我们在数学中常见的 阶乘计算（Factorial） 就可以用递归来定义：

​ $n!=n\times (n-1)!$

其中，基准情况（Base Case） 是 0! = 1，而 递归情况（Recursive Case） 则是 $n! = n \times (n-1)! $。基准情况用于终止递归，防止无限递归导致程序崩溃。

递归的重要性

递归在计算机科学中有着广泛的应用，以下是几个典型的场景：

• 数学计算（如斐波那契数列、指数计算、最大公约数计算）
• 数据结构（如树、图的遍历）
• 排序算法（如快速排序、归并排序）
• 搜索算法（如深度优先搜索 DFS）
• 动态规划（自顶向下的记忆化搜索）

在某些情况下，递归提供了一种更直观、自然的方式来描述问题，代码更简洁易读。然而，递归也存在性能问题，特别是在没有优化的情况下，可能会导致栈溢出（Stack Overflow） 或 重复计算。因此，在实际开发中，我们需要结合具体问题，选择合适的优化策略（如尾递归优化、记忆化递归、迭代替代递归等）。

递归与循环的对比

递归和循环（Iteration）在功能上存在一定的重叠，但它们各有优缺点：

对比项	递归	循环
代码可读性	适用于描述层次化问题，代码更简洁	适用于简单重复操作，代码结构清晰
性能	可能导致函数调用开销大，栈空间占用高	通常更高效，不会产生额外的调用栈
适用场景	适用于树形结构、分治算法	适用于线性迭代的任务
调试难度	递归调用栈深，调试较复杂	逻辑清晰，易于调试

递归是计算机科学中不可或缺的工具，掌握递归有助于更深入地理解算法设计思想。在接下来的章节中，我们将深入探讨递归的工作原理、优化策略、常见应用场景及其在 C++ 现代化编程中的实践。

2、递归函数的基本概念

2.1、什么是递归？

递归（Recursion）是一种函数调用自身的编程技术，它通过不断拆分问题来实现复杂问题的求解。在数学和计算机科学中，递归是一个基础且强大的工具，广泛应用于算法设计、数据结构操作和数学计算等领域。

递归通常由两个部分组成：

1. 基准情况（Base Case）——用于终止递归，防止无限递归导致程序崩溃。
2. 递归情况（Recursive Case）——定义如何将问题拆分为更小的子问题，并递归调用自身来求解。

示例：阶乘计算

数学上，阶乘 n! 的定义如下：

​ $n!=n\times (n-1)!$

其中，基准情况（Base Case） 是 0! = 1，而 递归情况（Recursive Case） 则是 $n! = n \times (n-1)! $。基准情况用于终止递归，防止无限递归导致程序崩溃。

对应的 C++ 代码如下：

#include 

// 计算阶乘的递归函数
int factorial(int n) {
    if (n == 0) return 1;  			// 基准情况
    return n * factorial(n - 1);  	// 递归调用
}

int main() {
    std::cout << "5! = " << factorial(5) << std::endl;  // 输出 120
    return 0;
}

执行流程

• factorial(5) 调用 factorial(4)
• factorial(4) 调用 factorial(3)
• factorial(3) 调用 factorial(2)
• factorial(2) 调用 factorial(1)
• factorial(1) 调用 factorial(0)
• factorial(0) 返回 1，然后逐层回溯，计算最终结果。

在执行 factorial(5) 时，函数会不断调用自身，直到 n == 0 时返回 1，然后逐步回溯计算最终结果。

2.2、递归的工作原理

递归的本质是**调用栈（Call Stack）**的管理：

• 每次函数调用时，都会在栈上分配新的栈帧（Stack Frame）。
• 递归层层深入，直至到达基准情况。
• 递归终止后，函数逐步返回，回溯至最初的调用者。

在 factorial(5) 运行时，调用栈的变化如下：

factorial(5)
 └─ factorial(4)
     └─ factorial(3)
         └─ factorial(2)
             └─ factorial(1)
                 └─ factorial(0) 	// 终止条件, 返回 1

回溯计算：

factorial(1) = 1 * factorial(0) = 1 * 1 = 1
factorial(2) = 2 * factorial(1) = 2 * 1 = 2
factorial(3) = 3 * factorial(2) = 3 * 2 = 6
factorial(4) = 4 * factorial(3) = 4 * 6 = 24
factorial(5) = 5 * factorial(4) = 5 * 24 = 120

最终结果 factorial(5) = 120。

2.3、递归的两个重要特性

2.3.1、终止条件

递归必须有终止条件，否则会导致无限递归，最终导致栈溢出（Stack Overflow）。 例如，错误的递归实现：

void infiniteRecursion() {
    std::cout << "Infinite loop!" << std::endl;
    infiniteRecursion();  	// 没有终止条件, 会无限调用
}

int main() {
    infiniteRecursion(); 	// 运行时将导致栈溢出
}

修正方案：添加终止条件

void limitedRecursion(int n) {
    if (n <= 0) return; 		// 终止条件
    std::cout << "Recursion level: " << n << std::endl;
    limitedRecursion(n - 1); 	// 递归调用
}

int main() {
    limitedRecursion(5);
}

2.3.2、递归深度

• 递归的调用深度受限于系统栈大小，如果递归层数过多，可能会导致栈溢出。
• 例如：

void deepRecursion(int n) {
    std::cout << "Level " << n << std::endl;
    deepRecursion(n + 1); 	// 递归深度无限增加
}

int main() {
    deepRecursion(1); 		// 运行一段时间后崩溃
}

避免递归过深的方法

• 改为迭代（如使用 for 或 while）
• 使用尾递归优化（Tail Recursion）
• 减少不必要的递归调用

2.4、小结

• 递归是通过函数调用自身来解决问题的方式。
• 必须包含基准情况，以防止无限递归。
• 递归消耗栈空间，可能会导致栈溢出，需要注意递归深度。

在下一节，我们将深入探讨 C++ 递归的详细实现及应用场景。

3、递归的分类

递归是编程中一种强大的工具，理解不同类型的递归对于优化代码和提升程序性能至关重要。按照递归调用方式和特征，我们可以将递归分为以下几类：

1. 按调用方式分类
   • 直接递归（Direct Recursion）
   • 间接递归（Indirect Recursion）
2. 按调用结构分类
   • 线性递归（Linear Recursion）
   • 树形递归（Tree Recursion）
3. 按递归调用位置分类
   • 头递归（Head Recursion）
   • 尾递归（Tail Recursion）
4. 按递归层级分类
   • 单层递归（Single-Level Recursion）
   • 多层递归（Multi-Level Recursion）

接下来，我们详细讲解这些递归类型，并配以示例代码。

3.1、按调用方式分类

3.1.1、直接递归（Direct Recursion）

直接递归是指函数在自身内部调用自身。这是最基本、最常见的递归方式。

示例：计算阶乘

#include 

int factorial(int n) {
    if (n == 0) return 1;  			// 终止条件
    return n * factorial(n - 1);  	// 递归调用
}

int main() {
    std::cout << "5! = " << factorial(5) << std::endl;  // 输出 120
    return 0;
}

递归调用顺序

factorial(5) → factorial(4) → factorial(3) → factorial(2) → factorial(1) → factorial(0)

回溯计算

factorial(0) = 1
factorial(1) = 1 * factorial(0) = 1 * 1 = 1
factorial(2) = 2 * factorial(1) = 2 * 1 = 2
factorial(3) = 3 * factorial(2) = 3 * 2 = 6
factorial(4) = 4 * factorial(3) = 4 * 6 = 24
factorial(5) = 5 * factorial(4) = 5 * 24 = 120

特点

• 递归函数直接调用自身。
• 代码结构清晰，符合数学归纳法思维。
• 需要基准情况避免无限递归。

3.1.2、间接递归（Indirect Recursion）

间接递归是指函数 A 调用函数 B，而函数 B 又调用函数 A，形成间接调用关系。

示例：函数 A、B 相互调用

#include 

void functionB(int n);

void functionA(int n) {
    if (n <= 0) return;
    std::cout << "A: " << n << std::endl;
    functionB(n - 1);
}

void functionB(int n) {
    if (n <= 0) return;
    std::cout << "B: " << n << std::endl;
    functionA(n - 2);
}

int main() {
    functionA(5);
    return 0;
}

执行过程

A: 5
B: 4
A: 2
B: 1

特点

• 函数之间相互调用，最终仍然需要基准情况来终止递归。
• 通常不如直接递归常见，但在某些问题（如解析嵌套表达式）中可能有用。

3.2、按调用结构分类

3.2.1、线性递归（Linear Recursion）

线性递归是指每次递归调用时只进行一次递归调用，即递归调用是单链式的，没有分叉。

示例：计算累加和

#include 

int sum(int n) {
    if (n == 0) return 0;
    return n + sum(n - 1);
}

int main() {
    std::cout << "Sum(5) = " << sum(5) << std::endl;  // 输出 15
    return 0;
}

特点

• 递归调用路径呈线性结构。
• 适合简单数学计算，如阶乘、求和。

3.2.2、树形递归（Tree Recursion）

树形递归是指每次递归调用多个子递归，导致调用次数呈指数级增长。

示例：计算斐波那契数列

#include 

int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    std::cout << "Fibonacci(5) = " << fibonacci(5) << std::endl;  // 输出 5
    return 0;
}

递归树展开

fibonacci(5)
├── fibonacci(4)
│   ├── fibonacci(3)
│   │   ├── fibonacci(2)
│   │   │   ├── fibonacci(1) → 1
│   │   │   ├── fibonacci(0) → 0
│   │   ├── fibonacci(1) → 1
│   ├── fibonacci(2)
│   │   ├── fibonacci(1) → 1
│   │   ├── fibonacci(0) → 0
├── fibonacci(3)
│   ├── fibonacci(2)
│   │   ├── fibonacci(1) → 1
│   │   ├── fibonacci(0) → 0
│   ├── fibonacci(1) → 1

特点

• 递归调用形成树状结构，每个节点会产生多个递归调用。
• 计算量随着 n 增长呈指数级增长（O(2^n)）。
• 需要优化，如 记忆化递归 或 动态规划。

3.3、按递归调用位置分类

3.3.1、头递归（Head Recursion）

头递归是指递归调用发生在函数的最前面，即先递归，再进行当前层的计算。

示例

void headRecursion(int n) {
    if (n == 0) return;
    headRecursion(n - 1);  	// 递归调用在前
    std::cout << n << " ";
}

特点

• 先递归到底，再回溯执行计算。
• 常用于倒序打印等问题。

3.2.2、尾递归（Tail Recursion）

尾递归是指递归调用发生在函数的最后一步，即先计算，再递归，这样可以优化成循环，减少栈空间消耗。

示例

void tailRecursion(int n) {
    if (n == 0) return;
    std::cout << n << " ";
    tailRecursion(n - 1);  // 递归调用在后
}

特点

• 可以优化成循环，避免栈溢出。
• 编译器可能进行尾递归优化（Tail Call Optimization, TCO）。

3.4、小结

• 直接递归和间接递归区分是否直接调用自身。
• 线性递归和树形递归反映递归结构的复杂度。
• 头递归和尾递归决定递归调用的位置和优化可能性。

理解这些分类有助于选择合适的递归策略，提高算法效率。