在 C 语言编程中，实现同一个功能往往有多种思路，其中循环 和递归 是最常用的两种编程范式。循环通过重复执行一段代码完成计算，递归则通过函数自身调用将问题拆解为更小的子问题。本文将以1 到 n 的累加求和 和斐波那契数列求解两个经典案例为例，用 C 语言分别实现循环和递归版本，并分析两种方式的核心逻辑、差异与适用场景，帮助大家理解两种编程思路的本质。
一、1 到 n 的累加求和：循环与递归的直观对比
累加求和是最基础的编程练习，从 1 累加到 n 的数学逻辑十分简单，用循环和递归实现的代码差异能让我们快速感知两种范式的不同。
1. 循环实现：迭代累加，步步为营
循环版本的求和逻辑非常直接，通过for循环从 1 遍历到 n，用一个变量保存累加的结果，每一次循环都将当前的 i 值加入结果中，遍历结束后返回结果即可。
cpp
#include <stdio.h>
// 定义求和函数，参数n为需要累加的最大值
int fun(int n)
{
// 初始化累加和为0，必须初始化为0，否则会出现随机值
int sum = 0;
// for循环：i从1开始，到n结束，每次自增1
for (int i = 1; i <= n; i++)
{
// 每次循环将当前的i值加到sum中，实现累加
sum += i;
}
// 循环结束后，返回最终的累加结果
return sum;
}
// 主函数，程序的入口
int main(int argc, char const *argv[])
{
// 调用fun函数，计算1-5的和，打印结果
printf("%d\n", fun(5)); // 输出15
return 0;
}核心逻辑 ：初始化累加变量sum为 0，通过循环依次将 1 到 n 的数值迭代加入sum，属于迭代思维，从基础值开始逐步构建结果，直到满足循环终止条件。
2. 递归实现：拆解问题，自顶向下
递归版本的求和思路是问题拆解 ：要计算 1 到 n 的和，只需先计算 1 到 n-1 的和，再加上 n 即可；而计算 1 到 n-1 的和，又可以拆解为计算 1 到 n-2 的和再加 n-1，以此类推，直到拆解到最基础的子问题n=1时，直接返回 1（递归的终止条件）。
cpp
#include <stdio.h>
// 递归求和函数，参数n为需要累加的最大值
int fun(int n)
{
// 递归终止条件：当n=1时，1的和就是1，不再递归调用
if (n == 1)
{
return 1;
}
// 递归核心公式：1~n的和 = 1~(n-1)的和 + n
else
{
// 调用自身函数，拆解问题，逐步缩小n的范围
return fun(n-1) + n;
}
}
// 主函数，程序入口
int main(int argc, char const *argv[])
{
// 调用递归函数，计算1-5的和，打印结果
printf("%d\n", fun(5)); // 输出15
return 0;
}核心逻辑 ：递归的关键是终止条件 和递推公式 ，本次求和的递推公式为f(n) = f(n-1) + n，终止条件为f(1)=1，缺少终止条件会导致函数无限递归，最终栈溢出。
二、斐波那契数列求解：循环更高效，递归更简洁
斐波那契数列是另一个经典的编程案例，数列定义为：F(1)=1，F(2)=1，F(n)=F(n-1)+F(n-2)（n≥3）。我们以求解第 6 项斐波那契数为例，分别用循环和递归实现，会发现两种方式的效率差异尤为明显。
1. 循环实现：递推计算，避免重复
循环版本的斐波那契求解采用递推思维，通过两个变量保存前两项的数值，从第 3 项开始，依次计算当前项为前两项之和，同时不断更新前两项的数值，直到计算到目标项。
cpp
#include <stdio.h>
// 循环实现斐波那契数列，n为要求解的项数
int fibonacci(int n)
{
// 边界判断：第1项和第2项的值都是1
if(n == 1 || n == 2)
{
return 1;
}
// 初始化：last2保存第n-2项，初始为第1项的值1
int last2 = 1;
// last1保存第n-1项，初始为第2项的值1
int last1 = 1;
// 存储当前计算的斐波那契数
int result = 0;
// 从第3项开始，循环计算到第n项
for (int i = 3; i <= n; i++)
{
// 当前项 = 前两项之和
result = last1 + last2;
// 更新：原n-1项变成新的n-2项
last2 = last1;
// 更新：当前计算的项变成新的n-1项
last1 = result;
}
// 循环结束，返回第n项的结果
return result;
}
// 主函数
int main(int argc, char const *argv[])
{
// 调用函数计算第6项斐波那契数，打印结果
printf("%d\n", fibonacci(6)); // 输出8
return 0;
}核心逻辑 ：利用循环从基础项（第 1、2 项）开始，逐步递推计算后续每一项，每一个数值仅计算一次，时间复杂度为O(n) ，空间复杂度为O(1)，效率极高。
2. 递归实现：简洁直观，但存在重复计算
递归版本的斐波那契实现完全贴合数列的数学定义，代码十分简洁，直接将递推公式F(n)=F(n-1)+F(n-2)作为函数自身调用的逻辑，终止条件为n==1或n==2时返回 1。
cpp
#include <stdio.h>
// 递归实现斐波那契数列，n为要求解的项数
int fibonacci(int n)
{
// 递归终止条件：第1项、第2项的值都为1
if (n == 1 || n == 2)
{
return 1;
}
// 递归核心公式：第n项 = 第n-1项 + 第n-2项
else
{
// 两次调用自身，分别计算前两项的值
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
// 主函数
int main(int argc, char const *argv[])
{
// 调用递归函数计算第6项，打印结果
printf("%d\n", fibonacci(6)); // 输出8
return 0;
}
核心逻辑 ：代码完全遵循数学定义，可读性强，但存在大量重复计算 。例如计算fibonacci(6)时，需要计算fibonacci(5)和fibonacci(4)，计算fibonacci(5)又需要计算fibonacci(4)和fibonacci(3)，其中fibonacci(4)、fibonacci(3)等会被多次计算，时间复杂度为O(2ⁿ)，当 n 较大时，程序运行效率会急剧下降。
三、循环与递归的核心差异与适用场景
通过上述两个案例的实现，我们可以总结出循环和递归的核心差异，并明确二者的适用场景，帮助大家在实际开发中选择更合适的方式。
1. 核心差异
| 特性 | 循环 | 递归 |
|---|---|---|
| 思维方式 | 迭代思维，从基础到结果，逐步构建 | 分治思维，从结果到基础，拆解问题 |
| 代码结构 | 稍繁琐，需定义循环变量和终止条件 | 极简洁，贴合数学公式，可读性强 |
| 时间效率 | 效率高，无重复计算 | 部分场景存在大量重复计算，效率低 |
| 空间效率 | 空间复杂度低，仅占用少量栈空间 | 每次递归都会创建函数栈帧，空间复杂度高，易栈溢出 |
| 终止条件 | 循环条件不满足时终止 | 必须显式定义，否则无限递归 |
2. 适用场景
循环的适用场景
- 大多数常规计算场景，尤其是需要高效执行的情况，如累加、递推、遍历等；
- 当 n 的数值较大时，循环能避免栈溢出和重复计算问题，稳定性更高；
- 适合处理逻辑相对简单，可通过迭代逐步完成的任务。
递归的适用场景
- 问题本身具有递归定义的特性，如斐波那契数列、阶乘、二叉树遍历、汉诺塔问题等，代码更简洁易维护；
- 适合处理分治问题，如快速排序、归并排序等，能将复杂问题拆解为多个相同的子问题；
- 注意：使用递归时需确保问题的拆解次数有限，且尽量通过记忆化递归（保存已计算的结果）避免重复计算，提升效率。
四、总结
循环和递归作为 C 语言中两种核心的编程方式，没有绝对的优劣，只有合适与否：
- 循环以效率和稳定性取胜，是开发中的首选方式，适用于大多数常规计算场景，代码虽稍繁琐，但运行效率高、资源占用少；
- 递归以简洁和可读性 见长，适用于具有递归定义的问题，代码贴合数学逻辑，但需注意终止条件 的定义和重复计算 、栈溢出问题。
在实际 C 语言开发中，我们可以根据问题的特性选择对应的方式：如果问题逻辑简单，追求高效，优先使用循环 ；如果问题具有明显的分治、递归特性，追求代码的简洁性和可读性，可使用递归，若存在重复计算，可结合数组或哈希表实现记忆化递归，兼顾效率和简洁性。