算法 | Recursion vs Iteration

注：本文为 “递归与 迭代” 相关合辑。
英文引文，机翻未校。
如有内容异常，请看原文。

---

Recursion Vs Iteration | 10 Differences (& When to use?)

递归与迭代 | 10 个区别（以及何时使用？）

Mar 14, 2022
2022年3月14日

By Riddhima Agarwal
作者：里德希玛·阿加瓦尔（Riddhima Agarwal）

Whenever we try to code, two terms, namely iteration and recursion, often pop up. And for a newcomer, these two can be a little confusing. If this is the case for you, then do not worry as we are here to help you out. Both these terms refer to two different code structures with the same ultimate goal: repeated execution of a set of sequential instructions. In this article, we will study what recursion is and what iteration is, followed by a table comparing the two. So, let’s get started.
每当我们尝试编写代码时，常会遇到两个术语——迭代和递归。对于新手而言，这两个概念可能有些令人困惑。如果您也有这样的困扰，无需担心，我们会为您提供帮助。这两个术语指代两种不同的代码结构，但最终目标一致：重复执行一组顺序指令。在本文中，我们将先分别学习什么是递归、什么是迭代，随后通过表格对比二者差异。那么，让我们开始吧。

What is Iteration?

什么是迭代？

In this type of code structure, loops are used to execute a set of instructions. In other words, an iterative code structure uses a repetition structure. Any part of code that uses a loop is said to follow an iterative code structure.
在这类代码结构中，循环（loop）被用于执行一组指令。换句话说，迭代代码结构采用重复结构（repetition structure）。任何使用循环的代码片段，都可称为遵循迭代代码结构。

To help you visualize this concept, let’s take an example: imagine a pile of books, with a key placed between two of the books. Our goal is to find that key. What you would do is pick up the books one by one, and each time you pick up a book, you check a condition: whether you have found the key. If you find the key, your task is done. However, if you haven’t, you continue picking up books from the pile one by one until you reach the bottom. This way of executing a task is known as the iterative model. Take a look at the flowchart below to further solidify this concept.
为帮助您直观理解该概念，我们举一个例子：假设有一堆书，其中两本书之间夹着一把钥匙，我们的目标是找到这把钥匙。此时，您会一本接一本地拿起书，每拿起一本就检查一个条件——是否找到了钥匙。如果找到钥匙，任务即完成；如果未找到，则继续从书堆中逐本取书，直到拿到最底下的书为止。这种任务执行方式被称为迭代模型。请查看下方流程图，以进一步巩固该概念。

In iteration, the set of statements executes until the condition in the iterative statement is True. When the condition evaluates to False, the iteration terminates. At any point in time, the state of an iteration is defined by its control variable. A control variable is the variable responsible for running a loop (in most cases, it is usually i or j). If no condition is specified, the loop will consume CPU cycles, and we will end up in a state known as an infinite loop.
在迭代过程中，语句集会持续执行，直到迭代语句中的条件为True（真）。当条件计算结果为False（假） 时，迭代终止。在任意时刻，迭代的状态都由其控制变量（control variable）定义。控制变量是负责驱动循环运行的变量（多数情况下通常为i或j）。若未指定条件，循环会持续占用CPU周期，最终导致程序陷入“无限循环（infinite loop）”状态。

The time complexity of a program following an iterative code structure can be easily calculated by counting the number of times the statements inside the loop are executed.
遵循迭代代码结构的程序，其时间复杂度可通过统计循环内部语句的执行次数轻松计算得出。

What is Recursion?

什么是递归？

Most newbies find recursion a little hard to understand, but it is a technique that all programmers should master. Do not worry—we will try to simplify this concept as much as possible.
大多数新手会觉得递归难以理解，但它是所有程序员都应掌握的技术。别担心，我们会尽量简化这个概念。

According to the Oxford English Dictionary, recursion is defined as “the repeated application of a recursive technique or definition.” Do you notice the recursion in this definition? To define “recursion,” they used the term “recursive.” We think this is a bit of an Easter egg.
根据《牛津英语词典》（Oxford English Dictionary）的定义，递归是“递归技术或递归定义的重复应用”。您是否发现这个定义中的“递归”痕迹？定义“recursion（递归）”时，词典使用了“recursive（递归的）”一词——我们觉得这算是一个小彩蛋。

Anyway, let’s start with a cool example of recursion. Take a look at PyPy’s logo—PyPy is a Just-In-Time Compiler implementation for Python.
无论如何，我们先从一个有趣的递归示例开始。看看PyPy的徽标吧——PyPy是Python的即时编译器（Just-In-Time Compiler）实现版本。

Another example of recursion is a snake biting its own tail and “feeding” itself. For a more relatable example: recursion is like when anxiety causes you to feel even more anxiety (one anxiety triggers another, creating a cycle).
另一个递归示例是“蛇咬自己的尾巴并自我‘进食’”。再举一个更贴近生活的例子：递归就像“焦虑引发更多焦虑”——一种焦虑触发另一种焦虑，形成循环。

In more technical terms, recursion occurs when a function calls itself in programming. Any function that calls itself is called a recursive function. However, to avoid infinite recursion, the function must include a base case (a termination condition). A recursive code terminates when the base case is met. A code example following the recursive structure looks like this:
从技术角度更精准地说，在编程中，当一个函数调用自身时，就会发生递归。任何调用自身的函数都称为“递归函数（recursive function）”。但为避免“无限递归（infinite recursion）”，函数必须包含一个基准条件（base case，即终止条件）。当基准条件满足时，递归代码便会终止。以下是一个遵循递归结构的代码示例：

Let’s understand recursion using a similar example to the one we used for iteration. Suppose you lost your key on a table cluttered with books. You start picking up items from the table at random—if the item you pick up is the key, congratulations, your task is done. However, if the item is a book, you go back to picking up another item from the table (this “going back to the action” is similar to recursion).
我们用一个与迭代示例类似的场景来理解递归：假设您的钥匙丢在一张堆满书的桌子上，您开始随机拿起桌上的物品——如果拿起的是钥匙，恭喜您，任务完成；但如果拿起的是书，您会继续回去拿起桌上的另一件物品（这种“回到原动作”的逻辑与递归相似）。

In a recursive structure, a stack is used to store the set of new local variables and parameters each time the function is called. Since recursion relies on the stack data structure, this creates overhead—making recursive code slower than iterative code. Writing recursive code is more complex, which makes it harder to interpret. However, recursion has one major advantage that offsets all its drawbacks: it can solve some extremely difficult problems that iteration cannot. This is what makes learning recursion so important.
在递归结构中，每次调用函数时，都会使用一个栈（stack） 来存储新的局部变量和参数集合。由于递归依赖栈数据结构，这会产生额外开销——导致递归代码比迭代代码运行速度更慢。递归代码的编写逻辑更复杂，因此也更难理解。但递归有一个核心优势，足以抵消其所有缺点：它能解决一些迭代无法解决的极复杂问题，这也正是学习递归的重要意义所在。

10 Differences Between Recursion and Iteration

递归与迭代的 10 个区别

Comparison Basis 比较基础	Recursion 递归	Iteration 迭代
Implementation 实现方式	Implemented by a function calling itself 由函数调用自身实现	Implemented using loops 使用循环实现
State 状态定义	Defined by parameter values stored in the stack 由存储在栈中的参数值定义	Defined by the value of the control variable 由控制变量的值定义
Syntax 语法要求	Only a termination condition (base case) is required 仅需终止条件（基准条件）	Includes initialization, condition, and increment/decrement of the control variable 需包含控制变量的初始化、循环条件及递增/递减操作
Termination 终止逻辑	The termination condition is defined within the function body; recursion ends when this condition is met (evaluates to True) 终止条件在函数体内定义，当条件满足（计算结果为True）时，递归终止	The termination condition is defined in the loop; the loop terminates when this condition is not met (evaluates to False) 终止条件在循环中定义，当条件不满足（计算结果为False）时，循环终止
No Termination Statement 无终止语句的后果	In the absence of a base case, infinite recursion occurs—this can cause a stack overflow error or crash the system 缺少基准条件时，会发生无限递归，可能导致栈溢出错误或系统崩溃	If no termination condition is specified, an infinite loop occurs, which consumes CPU cycles 未指定终止条件时，会发生无限循环，持续占用CPU周期
Code size 代码规模	Smaller than iterative code 比迭代代码更简洁（代码量更少）	Larger than recursive code 比递归代码更冗长（代码量更多）
Speed 运行速度	Slower due to the overhead of maintaining a stack 因维护栈的额外开销，运行速度较慢	Faster 运行速度更快
Time complexity 时间复杂度	Higher time complexity 时间复杂度更高	Easier to calculate (by counting the number of loop executions); generally has lower time complexity 更易计算（通过统计循环执行次数），通常时间复杂度更低
Utilization of Stack 栈的使用	Yes (relies on the stack to store function parameters and local variables) 是（依赖栈存储函数参数和局部变量）	No (does not require a stack) 否（无需使用栈）
Memory Utilization 内存占用	More memory is required (due to stack storage of recursive calls) 内存占用更多（因递归调用需栈存储数据）	Less memory is required 内存占用更少

When to use Recursion vs Iteration?

何时使用递归 vs 迭代？

The most common question that troubles most programmers is: when to use recursion and when to use iteration. Honestly, most code can be written using either iteration or recursion. However, recursion is intuitive in many scenarios, while iteration can be quite cumbersome in others—this is especially true when dealing with items that have a complex nested structure (e.g., nested lists). Below, we outline some guidelines to help you decide which approach is best for the problem you are solving.
困扰大多数程序员的常见问题是：何时用递归，何时用迭代？说实话，大多数代码既可以用迭代实现，也可以用递归实现。但在许多场景下，递归更直观，而迭代则显得繁琐——尤其是在处理具有复杂嵌套结构的对象（如嵌套列表）时。以下我们列出一些指导原则，帮助您判断哪种方法更适合当前要解决的问题。

Iterative code can become complicated and hard to interpret when solving complex problems. Good code should be easy for other programmers to understand and decode. To see this more clearly, try implementing any tree traversal (e.g., pre-order, in-order, or post-order) using both recursive and iterative approaches. You will find that writing the iterative version for such problems is difficult—it requires using an explicit stack or queue.
在解决复杂问题时，迭代代码可能会变得复杂且难以理解。优秀的代码应便于其他程序员理解和解读。为更清晰地体会这一点，您可以尝试用递归和迭代两种方式实现树的遍历（如前序遍历、中序遍历或后序遍历）。您会发现，此类问题的迭代版本编写难度较大——需要使用显式的栈或队列。

A method that can be naturally expressed recursively (e.g., calculating the Nth Fibonacci number, tree traversal, or graph traversal) may not be as easy to understand when expressed iteratively. Converting a recursive algorithm to an iterative one can be tricky, and verifying that the two algorithms are equivalent is also not straightforward.
有些方法天生适合用递归表达（如计算第N个斐波那契数、树遍历、图遍历），若改用迭代表达，理解难度会显著增加。将递归算法转换为迭代算法本身就很棘手，而验证两种算法是否等效也并非易事。

For problems that can be broken down into smaller subproblems, recursion is far better than iteration. Using recursion in the divide and conquer method can reduce the problem size at each step, and it takes less time than a naive iterative approach. Recursive solutions are often more “elegant” than iterative ones because they are easier to implement.
对于可分解为多个子问题的问题，递归远优于迭代。在分治算法中使用递归，可在每一步缩小问题规模，且比简单的迭代方法更节省时间。递归解决方案通常比迭代方案更“优雅”，因为其实现难度更低。

Simply put: if you notice a repeating pattern in your problem (e.g., Fibonacci sequence, tree-related questions, or graph-related questions), you should use recursion. Additionally, recursion uses more memory but is sometimes clearer and more readable. Using loops improves performance, but recursion can sometimes be more convenient for programmers.
简而言之：如果您发现问题中存在重复模式（如斐波那契数列、树相关问题、图相关问题），应选择递归。此外，递归虽占用更多内存，但有时代码更清晰、可读性更强；使用循环能提升性能，但递归对程序员而言有时更便捷。

Therefore, we suggest choosing the approach that feels intuitive, not overly complex, and clearly conveys your thought process. However, when performance and efficiency are critical factors, you should choose accordingly. In summary:
因此，我们建议选择“直观易懂、不过于复杂、能清晰传达思维过程”的实现方式。但当性能和效率是关键因素时，则需根据实际需求选择。总结如下：

1. Recursive functions are often slower than iterative functions. So, if speed is a priority, iteration is usually the better choice.
   递归函数通常比迭代函数慢。因此，若速度是首要考虑因素，迭代通常是更优选择。
2. If the stack limit is too restrictive (e.g., in environments with limited stack memory), iteration will be preferred over recursion.
   若栈限制较为严格（如在栈内存有限的环境中），迭代会比递归更适用。
3. Some problems are almost impossible to manage with iteration but can be programmed naturally with recursion. In such cases, the choice is obvious.
   有些问题用迭代几乎无法处理，但用递归却能自然地实现。这种情况下，选择递归的答案显而易见。

Conclusion

结论

Iteration and recursion are the basic building blocks of programming—without them, complex problems cannot be solved. In this article, we have provided a brief introduction to both terms and outlined the differences between them. To gain a deeper understanding of recursion, you can read Recursion in C++. Many algorithms can be implemented using either iterative or recursive methods. By the end of this article, we want you to remember this key takeaway: Iteration means loops, and recursion means a function calling itself.
迭代和递归是编程的基础构建模块——没有它们，就无法解决复杂问题。本文简要介绍了这两个术语，并梳理了二者的差异。许多算法既可用迭代实现，也可用递归实现。在本文结尾，我们希望您记住这个核心要点：迭代即循环，递归即函数调用自身。

---

数学推导中的递归与迭代

在数学推导（如矩阵分解）和计算机科学中，递归（Recursion） 与 迭代（Iteration） 都是实现“重复操作”的核心思想，但二者的逻辑本质、执行方式和适用场景有显著区别。

结合矩阵分块分解案例，可通过以下维度清晰对比：

一、定义与区别

对比维度	递归（Recursion）	迭代（Iteration）
本质逻辑	「自顶向下，分而治之」：将复杂问题拆解为更小的“同类子问题”，通过解决子问题反推原问题答案（依赖“自身调用自身”的逻辑）。	「自底向上，逐步推进」：用固定规则重复处理“递变的对象”，通过累积每一步的简单结果，最终逼近目标（依赖“循环重复”的逻辑）。
执行依赖	依赖“递归函数/步骤”的自我调用，以及“基线条件”（终止子问题）。	依赖“循环结构”（如for/while），以及“迭代变量”（记录当前状态）和“终止条件”。
问题视角	关注“如何把大问题拆成小问题”，不直接关注中间步骤的细节。	关注“每一步具体怎么做”，需明确中间状态的更新规则。

二、实例对比

矩阵 LU 分解分块过程 为例，分别用递归和迭代实现，更易理解差异：

1. 递归实现

• 问题拆解：要分解矩阵 $A$，先做两件事：
  ① 分解 $A$ 的“首列首行”得到基础项 ${\mathbf{l}}_1{\mathbf{u}}_1^{\ast }$；
  ② 把剩余的右下角子块 $A_2$ 视为“更小的同类问题”，递归调用同样的分解规则处理 $A_2$；
• 基线条件（终止子问题）：当子块 $A_k=0$（零矩阵）时，停止递归，返回空结果；
• 结果合并：将当前步骤的 ${\mathbf{l}}_1{\mathbf{u}}_1^{\ast }$ 与子块 $A_2$ 的递归分解结果相加，最终得到 $A={\sum }_{k=1}^r{\mathbf{l}}_k{\mathbf{u}}_k^{\ast }=LU$。

逻辑：分解 $A$ → 分解 $A_2$ → 分解 $A_3$ → … → 分解 $A_{r+1}=0$（终止）→ 反向合并结果。

2. 迭代实现（“逐步拆分”）

• 初始状态：设定待处理子块 $M=A$，结果累加项 $S=0$（零矩阵）；
• 循环规则：重复执行同一操作：
  ① 从当前子块 $M$ 中拆分出 ${\mathbf{l}}_k{\mathbf{u}}_k^{\ast }$，加入累加项 $S=S+{\mathbf{l}}_k{\mathbf{u}}_k^{\ast }$；
  ② 更新待处理子块 $M=M-{\mathbf{l}}_k{\mathbf{u}}_k^{\ast }$（即新的右下角子块，如 $A_2,A_3,\dots$）；
• 终止条件：当 $M=0$ 时，停止循环，此时 $S=LU$ 即为分解结果。

逻辑：处理 $A$ → 处理 $A_2$ → 处理 $A_3$ → … → 处理 $A_{r+1}=0$（终止）→ 直接输出累加结果 $S$。

三、特性对比

特性	递归（Recursion）	迭代（Iteration）
代码/推导简洁性	逻辑更抽象，推导/代码更短（无需手动管理中间状态）。例如矩阵分解的递归表述只需“拆分+调用自身”，无需写循环步骤。	逻辑更具体，推导/代码需明确每一步的状态更新（如子块替换、累加计算），但更直观。
效率与资源	可能存在“重复计算”（如未优化的递归），且依赖“调用栈”（数学推导中无栈问题，但计算机实现中栈过深可能溢出）。	无重复计算，无需额外栈资源，效率更高（尤其步骤较多时）。例如矩阵分解的迭代过程每步只处理一个子块，无冗余操作。
可读性	适合理解“问题拆分逻辑”（如矩阵分解的“分块思想”），但复杂递归可能难以追踪中间步骤。	适合理解“具体执行过程”（如每一步子块如何变化），中间状态清晰可见，易调试/验证。
适用场景	1. 问题天然可拆分为“同类子问题”（如矩阵分块、多项式分解）； 2. 推导逻辑需突出“分治思想”，无需关注细节步骤。	1. 问题可通过“固定规则逐步推进”（如矩阵迭代拆分、方程迭代求解）； 2. 需明确展示中间过程，或步骤数量较多（避免递归效率问题）。

四、总结

• 递归：“我解决不了这个大问题，但我能解决比它小一点的同类问题，直到最小的问题能直接回答，再拼出大问题的答案”；
• 迭代：“我从初始状态开始，每次按同一规则做一点改变，逐步靠近目标，直到达到条件就停止，此时的结果就是答案”。

在矩阵分解中，“分离递归”是用递归思想表述分解逻辑（突出分块思想），而若用“循环拆分子块、累加结果”则是迭代实现（突出具体步骤）——二者最终能得到相同的 $LU$ 分解结果，但逻辑路径完全不同。

---

算法分析中的递归与迭代

在算法分析中，递归和迭代的设计与评估需要从多个维度差异化考量，这些差异直接影响算法的效率、可读性和适用性。以下从分析视角、应用场景优劣对比及选择原则三方面展开说明：

一、算法分析时的差异考量点

考量维度	递归算法	迭代算法
时间复杂度分析	需考虑“递归调用树”的分支数量和深度，可能存在重复计算（如未优化的斐波那契递归，时间复杂度为 $O(2^n)$）。需通过“主定理”“递归树法”分析子问题分解后的累积代价。	直接分析循环次数和每次循环的操作代价，时间复杂度通常为循环变量的增长函数（如遍历数组的迭代算法，时间复杂度为 $O(n)$）。
空间复杂度分析	额外空间消耗主要来自“递归调用栈”，栈深度等于递归深度（如二叉树深度为 $h$ 的递归遍历，空间复杂度为 $O(h)$），极端情况下可能导致栈溢出。	空间复杂度由迭代变量和辅助数据结构决定，通常为 $O(1)$ 或 $O(n)$（如用数组实现的动态规划迭代解法，空间复杂度为 $O(n)$），无栈溢出风险。
终止条件验证	依赖“基线条件”（Base Case），需确保递归过程能最终触达基线条件，否则会无限递归导致崩溃（如未处理 $n=0$ 的阶乘递归）。	依赖循环终止条件（如 $i<n$），需确保迭代变量按预期更新并最终满足终止条件，否则会陷入死循环。
可读性与可维护性	逻辑与问题的数学定义更贴合（如二叉树的递归定义），代码简洁但复杂递归可能难以调试（需追踪调用栈）。	逻辑更直白但代码可能冗长（如手动模拟递归的迭代实现），调试时可直接观察中间变量状态。

二、不同场景下的应用优劣对比

1. 问题天然具有递归结构

• 递归优势：代码与问题结构高度一致，可读性极强。
  例：二叉树的前序遍历

  def preorder(node):if node is None:  # 基线条件returnprint(node.val)preorder(node.left)  # 递归处理左子树preorder(node.right) # 递归处理右子树
  

  递归直接反映“根→左→右”的遍历逻辑，无需手动维护栈。

• 迭代劣势：需手动模拟栈结构，代码冗余且易出错。
  例：二叉树前序遍历的迭代实现

  def preorder(root):stack = [root]while stack:  # 循环终止条件node = stack.pop()if node:print(node.val)stack.append(node.right)  # 手动维护访问顺序stack.append(node.left)
  

2. 存在大量重复子问题

• 递归劣势：未优化时会重复计算子问题，时间复杂度极高。
  例：未优化的斐波那契数列计算

  def fib(n):if n <= 1:return nreturn fib(n-1) + fib(n-2)  # 重复计算 fib(n-2) 等子问题
  

  时间复杂度为 $O(2^n)$，效率极低。

• 迭代优势：通过“自底向上”计算，避免重复子问题，效率更高。
  例：斐波那契数列的迭代实现

  def fib(n):if n <= 1:return na, b = 0, 1for _ in range(2, n+1):  # 迭代累积结果a, b = b, a + breturn b
  

  时间复杂度优化为 $O(n)$，空间复杂度 $O(1)$。

3. 深度优先搜索（DFS）与广度优先搜索（BFS）

• 递归适用于DFS：递归栈天然适配“深度优先”的探索逻辑。
  例：迷宫路径搜索（DFS）
  递归可直接通过函数调用栈记录当前路径，遇到死胡同自动回溯，代码简洁。

• 迭代适用于BFS：队列结构更适合“逐层扩散”的迭代逻辑，若用递归会因栈深度限制导致溢出。
  例：二叉树层序遍历（BFS）
  迭代通过队列控制节点访问顺序，避免递归栈过深（如对于高度为 $10^5$ 的链表式二叉树，递归会栈溢出，迭代则无此问题）。

4. 数学公式或分治算法

• 递归优势：分治思想与递归逻辑天然契合，代码直观。
  例：快速排序（分治算法）
  递归直接体现“选基准→分区→子数组排序”的分治步骤，逻辑清晰。

• 迭代劣势：需手动维护分区索引和待排序子数组，代码复杂。
  快速排序的迭代实现需用栈存储子数组的左右边界，模拟递归过程，可读性下降。

三、递归与迭代的选择原则

1. 优先选递归的场景：

   • 问题具有明确的递归结构（如树、图的遍历、分治算法）；
   • 递归实现能显著简化代码且递归深度可控（如深度不超过 $10^4$ 的场景）；
   • 需突出问题的数学逻辑而非执行细节（如算法推导、证明）。

2. 优先选迭代的场景：

   • 递归存在大量重复子问题（如动态规划、斐波那契数列）；
   • 递归深度可能过大（如处理长链表、大规模数组），有栈溢出风险；
   • 对时间或空间效率要求极高（迭代通常比递归更高效）。

3. 折中方案：
   对递归逻辑清晰但效率低的场景，可采用“尾递归优化”（将递归转化为迭代等价形式）或“记忆化递归”（缓存子问题结果，如斐波那契的 memoization 优化）。

总结

递归是“从问题本质出发”的抽象实现，适合逻辑表达；迭代是“从执行过程出发”的具体实现，适合效率优先。选择时需权衡问题结构、效率需求和实现复杂度。

---

via：

• Recursion Vs Iteration |10 Differences (& When to use?)
  https://favtutor.com/blogs/recursion-vs-iteration
• 递归方程的求解（代入、递归树和主方法）-CSDN博客
  https://blog.csdn.net/rebortt/article/details/111213961
• [算法导论] 递归式求解的三种方法_哪一种算法适用于递归求解-CSDN博客
  https://blog.csdn.net/spaceyqy/article/details/38819959
• recursion-and-iteration-review
  https://web.mit.edu/6.102/www/sp24/classes/11-recursive-data-types/recursion-and-iteration-review.html
• Recursion vs Iteration Comparison
  https://www.enjoyalgorithms.com/blog/difference-between-iteration-and-recursion
• Iteration and Recursion [迭代和递归] – A Libertine of Computer Science –
  https://csruiliu.github.io/blog/20160616-iteration-recursion/
• Recursion vs Iteration: What’s the Difference and When to Use Which? - DEV Community
  https://dev.to/nadim_ch0wdhury/recursion-vs-iteration-whats-the-difference-and-when-to-use-which-12dm