Add comparison between iteration and recursion.

Fix the figure of tail recursion.
Fix two links.

docs/chapter_computational_complexity/iteration_and_recursion.md

@@ -525,14 +525,16 @@
     [class]{}-[func]{tailRecur}
     ```
 
-两种递归的过程对比如下图所示。
+尾递归的执行过程如下图所示。对比普通递归和尾递归，求和操作的执行点是不同的。
 
 - **普通递归**：求和操作是在“归”的过程中执行的，每层返回后都要再执行一次求和操作。
 - **尾递归**：求和操作是在“递”的过程中执行的，“归”的过程只需层层返回。
 
 ![尾递归过程](iteration_and_recursion.assets/tail_recursion_sum.png)
 
-请注意，许多编译器或解释器并不支持尾递归优化。例如，Python 默认不支持尾递归优化，因此即使函数是尾递归形式，但仍然可能会遇到栈溢出问题。
+!!! tip
+
+    请注意，许多编译器或解释器并不支持尾递归优化。例如，Python 默认不支持尾递归优化，因此即使函数是尾递归形式，但仍然可能会遇到栈溢出问题。
 
 ### 递归树
 
@@ -629,3 +631,108 @@
 
 - 从算法角度看，搜索、排序、回溯、分治、动态规划等许多重要算法策略都直接或间接地应用这种思维方式。
 - 从数据结构角度看，递归天然适合处理链表、树和图的相关问题，因为它们非常适合用分治思想进行分析。
+
+## 两者对比
+
+总结以上内容，如下表所示，迭代和递归在实现、性能和适用性上有所不同。
+
+<p align="center"> 表 <id> &nbsp; 迭代与递归特点对比 </p>
+
+|          | 迭代                                   | 递归                                                         |
+| -------- | -------------------------------------- | ------------------------------------------------------------ |
+| 实现方式 | 循环结构                               | 函数调用自身                                                 |
+| 时间效率 | 效率通常较高，无函数调用开销           | 每次函数调用都会产生开销                                     |
+| 内存使用 | 通常使用固定大小的内存空间             | 累积函数调用可能使用大量的栈帧空间                           |
+| 适用问题 | 适用于简单循环任务，代码直观、可读性好 | 适用于子问题分解，如树、图、分治、回溯等，代码结构简洁、清晰 |
+
+!!! tip
+
+    如果感觉以下内容理解困难，可以在读完“栈”章节后再来复习。
+
+那么，迭代和递归具有什么内在联系呢？以上述的递归函数为例，求和操作在递归的“归”阶段进行。这意味着最初被调用的函数实际上是最后完成其求和操作的，**这种工作机制与栈的“先入后出”原则是异曲同工的**。
+
+事实上，“调用栈”和“栈帧空间”这类递归术语已经暗示了递归与栈之间的密切关系。
+
+1. **递**：当函数被调用时，系统会在“调用栈”上为该函数分配新的栈帧，用于存储函数的局部变量、参数、返回地址等数据。
+2. **归**：当函数完成执行并返回时，对应的栈帧会从“调用栈”上被移除，恢复之前函数的执行环境。
+
+因此，**我们可以使用一个显式的栈来模拟调用栈的行为**，从而将递归转化为迭代形式：
+
+=== "Python"
+
+    ```python title="recursion.py"
+    [class]{}-[func]{for_loop_recur}
+    ```
+
+=== "C++"
+
+    ```cpp title="recursion.cpp"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Java"
+
+    ```java title="recursion.java"
+    [class]{recursion}-[func]{forLoopRecur}
+    ```
+
+=== "C#"
+
+    ```csharp title="recursion.cs"
+    [class]{recursion}-[func]{forLoopRecur}
+    ```
+
+=== "Go"
+
+    ```go title="recursion.go"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Swift"
+
+    ```swift title="recursion.swift"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "JS"
+
+    ```javascript title="recursion.js"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "TS"
+
+    ```typescript title="recursion.ts"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Dart"
+
+    ```dart title="recursion.dart"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Rust"
+
+    ```rust title="recursion.rs"
+    [class]{}-[func]{for_loop_recur}
+    ```
+
+=== "C"
+
+    ```c title="recursion.c"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+=== "Zig"
+
+    ```zig title="recursion.zig"
+    [class]{}-[func]{forLoopRecur}
+    ```
+
+观察以上代码，当递归被转换为迭代后，代码变得更加复杂了。尽管迭代和递归在很多情况下可以互相转换，但也不一定值得这样做，有以下两点原因。
+
+- 转化后的代码可能更加难以理解，可读性更差。
+- 对于某些复杂问题，模拟系统调用栈的行为可能非常困难。
+
+总之，**选择迭代还是递归取决于特定问题的性质**。在编程实践中，权衡两者的优劣并根据情境选择合适的方法是至关重要的。