算法入门：深入理解递归

最新推荐文章于 2026-04-15 17:11:52 发布

原创最新推荐文章于 2026-04-15 17:11:52 发布 · 734 阅读 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

代码可运行

递归是编程中最强大且迷人的概念之一，它能将复杂问题优雅地简化为相同问题的更小版本。本文将带你从零开始掌握递归的核心思想与C语言实现。

1. 什么是递归？

递归是一种通过将问题分解为更小的自相似问题来解决问题的方法。在编程中，递归函数会调用自身来解决子问题，直到达到最简单的情况（称为基本情况）。

生活中的递归例子：

俄罗斯套娃：打开一个娃娃，里面是更小的相同结构的娃娃
分形图案：局部与整体具有相似性的几何图形
镜子中的镜子：无限反射的景象

2. 递归的核心要素

每个递归函数都包含两个关键部分：

基线条件（Base Case）：最简单的、不需要进一步递归的情况
递归步骤（Recursive Step）：将问题分解为更小的子问题，并调用自身解决

void recursiveFunction(parameters) {
    // 1. 检查基线条件
    if (base_case_condition) {
        // 直接返回结果
        return;
    }
    
    // 2. 递归步骤
    // 修改参数使问题规模变小
    recursiveFunction(modified_parameters);
}

3. 递归入门：阶乘计算

阶乘（n!）是最经典的递归示例：

n! = n × (n-1) × (n-2) × ... × 1

C语言递归实现：

#include <stdio.h>

// 递归计算阶乘
long factorial(int n) {
    // 基线条件：0! = 1
    if (n == 0) {
        return 1;
    }
    // 递归步骤：n! = n * (n-1)!
    else {
        return n * factorial(n - 1);
    }
}

int main() {
    int number = 5;
    printf("%d! = %ld\n", number, factorial(number));
    return 0;
}

执行过程分析（以5!为例）：

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

4. 递归进阶：斐波那契数列

斐波那契数列：每个数字是前两个数字之和

0, 1, 1, 2, 3, 5, 8, 13, 21, ...

C语言递归实现：

#include <stdio.h>

int fibonacci(int n) {
    // 基线条件
    if (n == 0) return 0;
    if (n == 1) return 1;
    
    // 递归步骤：F(n) = F(n-1) + F(n-2)
    return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
    int n = 6;
    printf("Fibonacci(%d) = %d\n", n, fibonacci(n));
    return 0;
}

递归树分析（fibonacci(4)）：

             fib(4)
            /      \
       fib(3)     fib(2)
       /    \     /    \
  fib(2) fib(1) fib(1) fib(0)
  /    \
fib(1) fib(0)

注意：这种简单递归实现存在大量重复计算，实际应用中应使用记忆化或迭代优化

5. 递归实战：汉诺塔问题

汉诺塔是展示递归威力的经典问题：

规则：

一次只能移动一个圆盘
大圆盘不能放在小圆盘上
将所有圆盘从A柱移动到C柱

C语言递归实现：

#include <stdio.h>

void hanoi(int n, char from, char to, char aux) {
    if (n == 1) {
        printf("将盘 %d 从 %c 移动到 %c\n", n, from, to);
        return;
    }
    
    // 1. 将n-1个盘子从起始柱移动到辅助柱
    hanoi(n - 1, from, aux, to);
    
    // 2. 将最大的盘子从起始柱移动到目标柱
    printf("将盘 %d 从 %c 移动到 %c\n", n, from, to);
    
    // 3. 将n-1个盘子从辅助柱移动到目标柱
    hanoi(n - 1, aux, to, from);
}

int main() {
    int disks = 3;
    printf("%d个盘的汉诺塔解法:\n", disks);
    hanoi(disks, 'A', 'C', 'B');
    return 0;
}

输出示例（3个盘）：

3个盘的汉诺塔解法:
将盘 1 从 A 移动到 C
将盘 2 从 A 移动到 B
将盘 1 从 C 移动到 B
将盘 3 从 A 移动到 C
将盘 1 从 B 移动到 A
将盘 2 从 B 移动到 C
将盘 1 从 A 移动到 C

6. 递归的优缺点分析

优点：

代码简洁优雅：表达复杂算法更直观
问题分解：自然匹配分治策略
易于证明正确性：数学归纳法的编程实现

缺点：

内存开销：每次调用创建新栈帧
重复计算：如朴素斐波那契实现
调试难度：多层调用增加理解难度
栈溢出风险：深度递归可能导致堆栈溢出

7. 递归优化策略

尾递归优化：编译器将递归转换为循环

// 尾递归阶乘示例
long factorial_tail(int n, long result) {
    if (n == 0) return result;
    return factorial_tail(n - 1, n * result);
}

记忆化技术：存储已计算结果

#define MAX 100
long memo[MAX] = {0};

long fibonacci_memo(int n) {
    if (n <= 1) return n;
    if (memo[n] != 0) return memo[n];
    
    memo[n] = fibonacci_memo(n-1) + fibonacci_memo(n-2);
    return memo[n];
}

迭代替代：使用循环代替递归

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;
}