迭代的兄弟——c++中的递归

原创已于 2025-06-26 18:15:47 修改 · 751 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法 #开发语言

于 2025-06-26 18:11:55 首次发布

小百科专栏收录该内容

6 篇文章

订阅专栏

一、递归的基本概念

递归（Recursion） 是一种函数直接或间接调用自身的编程技术。其核心思想是将复杂问题分解为规模更小的同类子问题，通过解决子问题逐步构建原问题的解。递归在数学归纳法、分治算法、树 / 图遍历等场景中应用广泛。

二、递归的执行机制

1. 函数调用栈（Call Stack）

每次函数调用时，系统会在栈中为其分配内存空间（包括参数、局部变量、返回地址等）。
递归调用时，多个函数实例会逐层压栈，直至满足终止条件后逐层返回（弹栈）。

2. 关键要素

终止条件：递归必须存在明确的停止条件，否则会导致栈溢出（Stack Overflow）。
递推关系：将原问题拆解为更小规模的子问题，子问题的解法与原问题一致。

三、递归的典型应用场景

1. 数学问题求解

（1）阶乘（Factorial）

公式：n!={1,n×(n−1)!,n=0n>0

代码实现：

cpp

#include <iostream>
using namespace std;

int factorial(int n) {
    if (n == 0) return 1; // 终止条件
    return n * factorial(n - 1); // 递推关系
}

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

（2）斐波那契数列（Fibonacci Sequence）

公式：Fib(n)=⎩⎨⎧0,1,Fib(n−1)+Fib(n−2),n=0n=1n>1

代码实现：

cpp

int fibonacci(int n) {
    if (n <= 1) return n; // 终止条件
    return fibonacci(n-1) + fibonacci(n-2); // 递推关系
}

2. 数据结构遍历

（1）二叉树遍历

前序遍历：根节点 → 左子树 → 右子树
中序遍历：左子树 → 根节点 → 右子树
后序遍历：左子树 → 右子树 → 根节点

代码示例（前序遍历）：

cpp

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void preorderTraversal(TreeNode* root) {
    if (root == nullptr) return; // 终止条件（空节点）
    cout << root->val << " "; // 访问根节点
    preorderTraversal(root->left); // 递归遍历左子树
    preorderTraversal(root->right); // 递归遍历右子树
}

3. 分治算法

（1）快速排序（Quicksort）

步骤：
1. 选择基准值（Pivot）；
2. 将数组分为小于、等于、大于基准值的三部分；
3. 递归对左右子数组排序。

代码框架：

cpp

void quicksort(int arr[], int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high); // 分区操作
        quicksort(arr, low, pivotIndex - 1); // 递归左子数组
        quicksort(arr, pivotIndex + 1, high); // 递归右子数组
    }
}

四、递归与迭代的对比

特性	递归	迭代（循环）
代码复杂度	逻辑简洁，符合数学建模思维	需手动维护循环变量和状态
空间复杂度	最坏情况下为 O(n)（栈深度）	通常为 O(1)（仅需常数空间）
执行效率	函数调用存在额外开销	效率更高（无函数调用开销）
适用场景	树 / 图遍历、分治算法、数学递归问题	高性能要求场景、深度较大的循环

五、递归的常见问题与优化

1. 栈溢出（Stack Overflow）

原因：递归深度过大（如 n>104 时的阶乘计算）。
解决方案：
- 改用迭代（循环）实现（如尾递归优化，部分编译器支持）。
- 手动模拟栈（用 std::stack 实现非递归遍历）。

迭代实现斐波那契数列：

cpp

int fibonacci_iterative(int n) {
    if (n <= 1) return n;
    int a = 0, b = 1, c;
    for (int i = 2; i <= n; ++i) {
        c = a + b;
        a = b;
        b = c;
    }
    return b;
}

2. 重复计算（Overlapping Subproblems）

场景：斐波那契数列递归实现中，子问题被重复计算（如 fib(5) 需计算 fib(3) 和 fib(4)，而 fib(4) 又需计算 fib(3)）。
优化方法：
- 记忆化搜索（Memoization）：用数组或哈希表存储已计算的子问题结果。
- 动态规划（Dynamic Programming）：自底向上计算子问题，避免重复递归。

记忆化搜索实现斐波那契数列：

cpp

#include <unordered_map>
using namespace std;

unordered_map<int, int> memo; // 存储子问题结果

int fibonacci_memo(int n) {
    if (n <= 1) return n;
    if (memo.count(n)) return memo[n]; // 查缓存
    int result = fibonacci_memo(n-1) + fibonacci_memo(n-2);
    memo[n] = result; // 缓存结果
    return result;
}