C 语言实例 – 阶乘（手把手讲解）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在编程学习的旅程中，阶乘（Factorial）是一个经典且重要的数学问题，它不仅能够帮助我们理解基础的循环和递归逻辑，还能为后续的算法学习奠定基础。本文将以“C 语言实例 – 阶乘”为主题，从零开始逐步讲解阶乘的实现方法、优化技巧以及实际应用场景。无论是编程初学者还是希望巩固基础的中级开发者，都能通过本文获得系统化的知识梳理与实用代码示例。

1. 阶乘的基本概念

1.1 什么是阶乘？

阶乘是指一个正整数 n 与所有比它小的正整数的乘积，记作 n!。例如：

• 5! = 5 × 4 × 3 × 2 × 1 = 120
• 0! = 1（数学定义，需特别注意）

可以将阶乘想象为一个接力赛：每个数都要“接力”乘以它前面的所有数，直到乘到 1。这个过程既可以用循环迭代实现，也可以用递归方法完成。

1.2 阶乘的数学意义

阶乘在组合数学、概率论等领域有广泛应用，例如计算排列组合的数量：

• 排列数：从 n 个不同元素中取出 k 个的排列数为 n! / (n−k)!
• 组合数：从 n 个不同元素中取出 k 个的组合数为 n! / (k! × (n−k)!))

理解阶乘的数学背景，有助于我们在编程中结合实际问题选择最优解法。

2. C 语言实现阶乘的方法

2.1 方法一：迭代法（Iteration）

迭代法通过循环结构逐步计算阶乘，适合编程初学者掌握。

2.1.1 实现步骤

1. 初始化变量：定义一个变量（如 result）存储结果，初始值设为 1。
2. 循环计算：从 1 到 n，逐步将每个数乘入 result 中。
3. 返回结果：循环结束后，result 即为 n!。

2.1.2 代码示例

#include <stdio.h>  

long long factorial_iterative(int n) {  
    long long result = 1;  
    for (int i = 1; i <= n; i++) {  
        result *= i;  
    }  
    return result;  
}  

int main() {  
    int num = 5;  
    printf("%d! = %lld\n", num, factorial_iterative(num));  
    return 0;  
}  

2.1.3 代码解析

• 函数返回类型：long long 可以存储较大的阶乘结果（如 20! 约为 2.4e18）。
• 循环边界：i 从 1 开始，到 n 结束，确保所有数都被乘入。
• 时间复杂度：O(n)，效率较高，适合大多数场景。

2.2 方法二：递归法（Recursion）

递归法通过函数自身调用实现阶乘计算，其核心思想是将问题分解为更小的子问题。

2.2.1 实现原理

阶乘的递归公式为：

• base case：当 n == 0 或 n == 1 时，返回 1。
• 递归 case：n! = n × (n-1)!

2.2.2 代码示例

#include <stdio.h>  

long long factorial_recursive(int n) {  
    if (n == 0 || n == 1) {  
        return 1;  
    }  
    return n * factorial_recursive(n - 1);  
}  

int main() {  
    int num = 5;  
    printf("%d! = %lld\n", num, factorial_recursive(num));  
    return 0;  
}  

2.2.3 代码解析

• 递归终止条件：必须明确 n == 0 或 n == 1，否则会导致无限递归。
• 递归调用：每次调用 factorial_recursive(n - 1)，将问题规模缩小 1。
• 时间复杂度：O(n)，但递归的函数调用栈可能占用更多内存，尤其当 n 较大时。

3. 阶乘的优化与扩展

3.1 处理大数阶乘：字符串模拟乘法

当 n 超过 20 时，long long 的存储范围（约 9e18）将无法容纳结果。此时需要将阶乘结果存储为字符串，通过模拟乘法运算实现大数计算。

3.1.1 实现思路

1. 初始化字符串：用字符串 result 存储当前阶乘值，初始值为 "1"。
2. 逐位相乘：从 2 到 n，每次将当前数与 result 中的每一位相乘，并处理进位。
3. 逆序存储：将结果逆序存储，方便逐位处理。

3.1.2 代码示例

#include <stdio.h>  
#include <string.h>  

void multiply(char *result, int n) {  
    int length = strlen(result);  
    int carry = 0;  
    for (int i = 0; i < length; i++) {  
        int product = (result[i] - '0') * n + carry;  
        result[i] = (product % 10) + '0';  
        carry = product / 10;  
    }  
    while (carry) {  
        char *new_result = (char *)malloc((strlen(result) + 2) * sizeof(char));  
        strcpy(new_result, result);  
        new_result[strlen(result)] = (carry % 10) + '0';  
        new_result[strlen(result) + 1] = '\0';  
        free(result);  
        result = new_result;  
        carry /= 10;  
    }  
}  

char* factorial_large(int n) {  
    char *result = (char *)malloc(2 * sizeof(char));  
    strcpy(result, "1");  
    for (int i = 2; i <= n; i++) {  
        multiply(result, i);  
    }  
    return result;  
}  

int main() {  
    int num = 25;  
    char *result = factorial_large(num);  
    printf("%d! = %s\n", num, result);  
    free(result);  
    return 0;  
}  

3.1.3 关键点解析

• 字符串操作：通过逐位相乘和进位处理，模拟大数运算。
• 动态内存管理：当进位超过当前字符串长度时，需动态扩展内存。
• 时间复杂度：O(n²)，但能处理非常大的 n（如 100!）。

3.2 性能对比与选择建议

选择建议：

• 小规模计算（n ≤ 20）：优先选择迭代法或递归法。
• 大规模计算（n > 20）：必须使用字符串模拟法。

4. 实际应用场景与案例

4.1 组合数的计算

在统计问题中，计算组合数需要阶乘的支持。例如，从 52 张扑克牌中选出 5 张的组合数为：

long long combination(int n, int k) {  
    return factorial_iterative(n) / (factorial_iterative(k) * factorial_iterative(n - k));  
}  

4.2 排列问题

在算法题中，阶乘可用于判断全排列的可能数量。例如，输入字符串 "abc" 的全排列共有 3! = 6 种。

5. 常见错误与调试技巧

5.1 错误一：未处理 n = 0 的情况

错误代码：

if (n == 1) return 1; // 忽略了 n == 0 的情况  

修正：在条件判断中明确包含 n == 0。

5.2 错误二：数据类型溢出

错误场景：当计算 20! 时，若使用 int（最大值约 2e9）存储，结果会溢出。
解决方案：改用 long long 或字符串模拟法。

5.3 错误三：递归栈溢出

错误场景：当 n = 10000 时，递归法会因栈深度过大导致程序崩溃。
解决方案：改用迭代法或增加系统栈大小（非推荐）。

结论

通过本文的讲解，我们系统学习了阶乘的数学定义、C 语言实现方法、优化技巧以及实际应用场景。无论是编程初学者通过迭代与递归法理解基础逻辑，还是中级开发者通过大数阶乘案例提升复杂问题的解决能力，阶乘问题都能成为一条深入 C 语言核心的实践路径。

下一步行动：

1. 尝试将代码中的 factorial_iterative 函数改写为递归版本，并测试其正确性。
2. 使用字符串模拟法计算 100!，并观察结果的正确性。
3. 探索阶乘在组合数学中的更多应用场景，例如排列生成算法。

掌握阶乘的实现与优化，不仅是对编程技术的巩固，更是打开算法与数据结构世界的一把钥匙。希望本文能成为你编程旅程中的一块坚实基石！