CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-04-13 18:00:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

deploy

Browse Source
This commit is contained in:
krahets
2023-11-09 05:13:54 +08:00
parent 9a09f9407e
commit 3f666fa676
85 changed files with 619 additions and 610 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
chapter_computational_complexity/index.html
View File

@@ -3292,7 +3292,7 @@
<!-- Page content -->
<h1 id="2">第 2 章 &nbsp; 复杂度分析<a class="headerlink" href="#2" title="Permanent link">&para;</a></h1>
<div class="center-table">
<p><a class="glightbox" href="../assets/covers/chapter_complexity_analysis.jpg" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="复杂度分析" src="../assets/covers/chapter_complexity_analysis.jpg" width="600" /></a></p>
<p><a class="glightbox" href="../assets/covers/chapter_complexity_analysis.jpg" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="复杂度分析" class="cover-image" src="../assets/covers/chapter_complexity_analysis.jpg" /></a></p>
</div>
<div class="admonition abstract">
<p class="admonition-title">Abstract</p>

12
chapter_computational_complexity/iteration_and_recursion/index.html
View File

@@ -3627,7 +3627,7 @@
</div>
</div>
<p>图 2-1 展示了该求和函数的流程框图。</p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/iteration.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="求和函数的流程框图" src="../iteration_and_recursion.assets/iteration.png" /></a></p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/iteration.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="求和函数的流程框图" class="animation-figure" src="../iteration_and_recursion.assets/iteration.png" /></a></p>
<p align="center"> 图 2-1 &nbsp; 求和函数的流程框图 </p>
<p>此求和函数的操作数量与输入数据大小 <span class="arithmatex">\(n\)</span> 成正比，或者说成“线性关系”。实际上，<strong>时间复杂度描述的就是这个“线性关系”</strong>。相关内容将会在下一节中详细介绍。</p>
@@ -4195,7 +4195,7 @@
</div>
</div>
<p>图 2-2 给出了该嵌套循环的流程框图。</p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/nested_iteration.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="嵌套循环的流程框图" src="../iteration_and_recursion.assets/nested_iteration.png" /></a></p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/nested_iteration.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="嵌套循环的流程框图" class="animation-figure" src="../iteration_and_recursion.assets/nested_iteration.png" /></a></p>
<p align="center"> 图 2-2 &nbsp; 嵌套循环的流程框图 </p>
<p>在这种情况下，函数的操作数量与 <span class="arithmatex">\(n^2\)</span> 成正比，或者说算法运行时间和输入数据大小 <span class="arithmatex">\(n\)</span> 成“平方关系”。</p>
@@ -4374,7 +4374,7 @@
</div>
</div>
<p>图 2-3 展示了该函数的递归过程。</p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/recursion_sum.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="求和函数的递归过程" src="../iteration_and_recursion.assets/recursion_sum.png" /></a></p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/recursion_sum.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="求和函数的递归过程" class="animation-figure" src="../iteration_and_recursion.assets/recursion_sum.png" /></a></p>
<p align="center"> 图 2-3 &nbsp; 求和函数的递归过程 </p>
<p>虽然从计算角度看，迭代与递归可以得到相同的结果，<strong>但它们代表了两种完全不同的思考和解决问题的范式</strong>。</p>
@@ -4394,7 +4394,7 @@
<li>递归调用函数会产生额外的开销。<strong>因此递归通常比循环的时间效率更低</strong>。</li>
</ul>
<p>如图 2-4 所示，在触发终止条件前，同时存在 <span class="arithmatex">\(n\)</span> 个未返回的递归函数，<strong>递归深度为 <span class="arithmatex">\(n\)</span></strong> 。</p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/recursion_sum_depth.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="递归调用深度" src="../iteration_and_recursion.assets/recursion_sum_depth.png" /></a></p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/recursion_sum_depth.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="递归调用深度" class="animation-figure" src="../iteration_and_recursion.assets/recursion_sum_depth.png" /></a></p>
<p align="center"> 图 2-4 &nbsp; 递归调用深度 </p>
<p>在实际中，编程语言允许的递归深度通常是有限的，过深的递归可能导致栈溢出报错。</p>
@@ -4546,7 +4546,7 @@
<li><strong>普通递归</strong>：求和操作是在“归”的过程中执行的，每层返回后都要再执行一次求和操作。</li>
<li><strong>尾递归</strong>：求和操作是在“递”的过程中执行的，“归”的过程只需层层返回。</li>
</ul>
<p><a class="glightbox" href="../iteration_and_recursion.assets/tail_recursion_sum.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="尾递归过程" src="../iteration_and_recursion.assets/tail_recursion_sum.png" /></a></p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/tail_recursion_sum.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="尾递归过程" class="animation-figure" src="../iteration_and_recursion.assets/tail_recursion_sum.png" /></a></p>
<p align="center"> 图 2-5 &nbsp; 尾递归过程 </p>
<div class="admonition tip">
@@ -4726,7 +4726,7 @@
</div>
</div>
<p>观察以上代码，我们在函数内递归调用了两个函数，<strong>这意味着从一个调用产生了两个调用分支</strong>。如图 2-6 所示，这样不断递归调用下去，最终将产生一个层数为 <span class="arithmatex">\(n\)</span> 的「递归树 recursion tree」。</p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/recursion_tree.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="斐波那契数列的递归树" src="../iteration_and_recursion.assets/recursion_tree.png" /></a></p>
<p><a class="glightbox" href="../iteration_and_recursion.assets/recursion_tree.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="斐波那契数列的递归树" class="animation-figure" src="../iteration_and_recursion.assets/recursion_tree.png" /></a></p>
<p align="center"> 图 2-6 &nbsp; 斐波那契数列的递归树 </p>
<p>本质上看，递归体现“将问题分解为更小子问题”的思维范式，这种分治策略是至关重要的。</p>

10
chapter_computational_complexity/space_complexity/index.html
View File

@@ -3478,7 +3478,7 @@
<li><strong>指令空间</strong>：用于保存编译后的程序指令，在实际统计中通常忽略不计。</li>
</ul>
<p>在分析一段程序的空间复杂度时，<strong>我们通常统计暂存数据、栈帧空间和输出数据三部分</strong>。</p>
<p><a class="glightbox" href="../space_complexity.assets/space_types.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="算法使用的相关空间" src="../space_complexity.assets/space_types.png" /></a></p>
<p><a class="glightbox" href="../space_complexity.assets/space_types.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="算法使用的相关空间" class="animation-figure" src="../space_complexity.assets/space_types.png" /></a></p>
<p align="center"> 图 2-15 &nbsp; 算法使用的相关空间 </p>
<div class="tabbed-set tabbed-alternate" data-tabs="1:12"><input checked="checked" id="__tabbed_1_1" name="__tabbed_1" type="radio" /><input id="__tabbed_1_2" name="__tabbed_1" type="radio" /><input id="__tabbed_1_3" name="__tabbed_1" type="radio" /><input id="__tabbed_1_4" name="__tabbed_1" type="radio" /><input id="__tabbed_1_5" name="__tabbed_1" type="radio" /><input id="__tabbed_1_6" name="__tabbed_1" type="radio" /><input id="__tabbed_1_7" name="__tabbed_1" type="radio" /><input id="__tabbed_1_8" name="__tabbed_1" type="radio" /><input id="__tabbed_1_9" name="__tabbed_1" type="radio" /><input id="__tabbed_1_10" name="__tabbed_1" type="radio" /><input id="__tabbed_1_11" name="__tabbed_1" type="radio" /><input id="__tabbed_1_12" name="__tabbed_1" type="radio" /><div class="tabbed-labels"><label for="__tabbed_1_1">Python</label><label for="__tabbed_1_2">C++</label><label for="__tabbed_1_3">Java</label><label for="__tabbed_1_4">C#</label><label for="__tabbed_1_5">Go</label><label for="__tabbed_1_6">Swift</label><label for="__tabbed_1_7">JS</label><label for="__tabbed_1_8">TS</label><label for="__tabbed_1_9">Dart</label><label for="__tabbed_1_10">Rust</label><label for="__tabbed_1_11">C</label><label for="__tabbed_1_12">Zig</label></div>
@@ -4104,7 +4104,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
\text{常数阶} &lt; \text{对数阶} &lt; \text{线性阶} &lt; \text{平方阶} &lt; \text{指数阶}
\end{aligned}
\]</div>
<p><a class="glightbox" href="../space_complexity.assets/space_complexity_common_types.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="常见的空间复杂度类型" src="../space_complexity.assets/space_complexity_common_types.png" /></a></p>
<p><a class="glightbox" href="../space_complexity.assets/space_complexity_common_types.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="常见的空间复杂度类型" class="animation-figure" src="../space_complexity.assets/space_complexity_common_types.png" /></a></p>
<p align="center"> 图 2-16 &nbsp; 常见的空间复杂度类型 </p>
<h3 id="1-o1">1. &nbsp; 常数阶 <span class="arithmatex">\(O(1)\)</span><a class="headerlink" href="#1-o1" title="Permanent link">&para;</a></h3>
@@ -4783,7 +4783,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
</div>
</div>
</div>
<p><a class="glightbox" href="../space_complexity.assets/space_complexity_recursive_linear.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="递归函数产生的线性阶空间复杂度" src="../space_complexity.assets/space_complexity_recursive_linear.png" /></a></p>
<p><a class="glightbox" href="../space_complexity.assets/space_complexity_recursive_linear.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="递归函数产生的线性阶空间复杂度" class="animation-figure" src="../space_complexity.assets/space_complexity_recursive_linear.png" /></a></p>
<p align="center"> 图 2-17 &nbsp; 递归函数产生的线性阶空间复杂度 </p>
<h3 id="3-on2">3. &nbsp; 平方阶 <span class="arithmatex">\(O(n^2)\)</span><a class="headerlink" href="#3-on2" title="Permanent link">&para;</a></h3>
@@ -5118,7 +5118,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
</div>
</div>
</div>
<p><a class="glightbox" href="../space_complexity.assets/space_complexity_recursive_quadratic.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="递归函数产生的平方阶空间复杂度" src="../space_complexity.assets/space_complexity_recursive_quadratic.png" /></a></p>
<p><a class="glightbox" href="../space_complexity.assets/space_complexity_recursive_quadratic.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="递归函数产生的平方阶空间复杂度" class="animation-figure" src="../space_complexity.assets/space_complexity_recursive_quadratic.png" /></a></p>
<p align="center"> 图 2-18 &nbsp; 递归函数产生的平方阶空间复杂度 </p>
<h3 id="4-o2n">4. &nbsp; 指数阶 <span class="arithmatex">\(O(2^n)\)</span><a class="headerlink" href="#4-o2n" title="Permanent link">&para;</a></h3>
@@ -5268,7 +5268,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n^2) &lt; O(2^n) \newline
</div>
</div>
</div>
<p><a class="glightbox" href="../space_complexity.assets/space_complexity_exponential.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="满二叉树产生的指数阶空间复杂度" src="../space_complexity.assets/space_complexity_exponential.png" /></a></p>
<p><a class="glightbox" href="../space_complexity.assets/space_complexity_exponential.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="满二叉树产生的指数阶空间复杂度" class="animation-figure" src="../space_complexity.assets/space_complexity_exponential.png" /></a></p>
<p align="center"> 图 2-19 &nbsp; 满二叉树产生的指数阶空间复杂度 </p>
<h3 id="5-olog-n">5. &nbsp; 对数阶 <span class="arithmatex">\(O(\log n)\)</span><a class="headerlink" href="#5-olog-n" title="Permanent link">&para;</a></h3>

16
chapter_computational_complexity/time_complexity/index.html
View File

@@ -3954,7 +3954,7 @@
<li>算法 <code>B</code> 中的打印操作需要循环 <span class="arithmatex">\(n\)</span> 次，算法运行时间随着 <span class="arithmatex">\(n\)</span> 增大呈线性增长。此算法的时间复杂度被称为“线性阶”。</li>
<li>算法 <code>C</code> 中的打印操作需要循环 <span class="arithmatex">\(1000000\)</span> 次，虽然运行时间很长，但它与输入数据大小 <span class="arithmatex">\(n\)</span> 无关。因此 <code>C</code> 的时间复杂度和 <code>A</code> 相同，仍为“常数阶”。</li>
</ul>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_simple_example.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="算法 A、B 和 C 的时间增长趋势" src="../time_complexity.assets/time_complexity_simple_example.png" /></a></p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_simple_example.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="算法 A、B 和 C 的时间增长趋势" class="animation-figure" src="../time_complexity.assets/time_complexity_simple_example.png" /></a></p>
<p align="center"> 图 2-7 &nbsp; 算法 A、B 和 C 的时间增长趋势 </p>
<p>相较于直接统计算法运行时间，时间复杂度分析有哪些特点呢？</p>
@@ -4124,7 +4124,7 @@ T(n) = 3 + 2n
<p>若存在正实数 <span class="arithmatex">\(c\)</span> 和实数 <span class="arithmatex">\(n_0\)</span> ，使得对于所有的 <span class="arithmatex">\(n &gt; n_0\)</span> ，均有 <span class="arithmatex">\(T(n) \leq c \cdot f(n)\)</span> ，则可认为 <span class="arithmatex">\(f(n)\)</span> 给出了 <span class="arithmatex">\(T(n)\)</span> 的一个渐近上界，记为 <span class="arithmatex">\(T(n) = O(f(n))\)</span> 。</p>
</div>
<p>如图 2-8 所示，计算渐近上界就是寻找一个函数 <span class="arithmatex">\(f(n)\)</span> ，使得当 <span class="arithmatex">\(n\)</span> 趋向于无穷大时，<span class="arithmatex">\(T(n)\)</span> 和 <span class="arithmatex">\(f(n)\)</span> 处于相同的增长级别，仅相差一个常数项 <span class="arithmatex">\(c\)</span> 的倍数。</p>
<p><a class="glightbox" href="../time_complexity.assets/asymptotic_upper_bound.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="函数的渐近上界" src="../time_complexity.assets/asymptotic_upper_bound.png" /></a></p>
<p><a class="glightbox" href="../time_complexity.assets/asymptotic_upper_bound.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="函数的渐近上界" class="animation-figure" src="../time_complexity.assets/asymptotic_upper_bound.png" /></a></p>
<p align="center"> 图 2-8 &nbsp; 函数的渐近上界 </p>
<h2 id="233">2.3.3 &nbsp; 推算方法<a class="headerlink" href="#233" title="Permanent link">&para;</a></h2>
@@ -4399,7 +4399,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n \log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!
\text{常数阶} &lt; \text{对数阶} &lt; \text{线性阶} &lt; \text{线性对数阶} &lt; \text{平方阶} &lt; \text{指数阶} &lt; \text{阶乘阶}
\end{aligned}
\]</div>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_common_types.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="常见的时间复杂度类型" src="../time_complexity.assets/time_complexity_common_types.png" /></a></p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_common_types.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="常见的时间复杂度类型" class="animation-figure" src="../time_complexity.assets/time_complexity_common_types.png" /></a></p>
<p align="center"> 图 2-9 &nbsp; 常见的时间复杂度类型 </p>
<h3 id="1-o1">1. &nbsp; 常数阶 <span class="arithmatex">\(O(1)\)</span><a class="headerlink" href="#1-o1" title="Permanent link">&para;</a></h3>
@@ -5000,7 +5000,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n \log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!
</div>
</div>
<p>图 2-10 对比了常数阶、线性阶和平方阶三种时间复杂度。</p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_constant_linear_quadratic.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="常数阶、线性阶和平方阶的时间复杂度" src="../time_complexity.assets/time_complexity_constant_linear_quadratic.png" /></a></p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_constant_linear_quadratic.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="常数阶、线性阶和平方阶的时间复杂度" class="animation-figure" src="../time_complexity.assets/time_complexity_constant_linear_quadratic.png" /></a></p>
<p align="center"> 图 2-10 &nbsp; 常数阶、线性阶和平方阶的时间复杂度 </p>
<p>以冒泡排序为例，外层循环执行 <span class="arithmatex">\(n - 1\)</span> 次，内层循环执行 <span class="arithmatex">\(n-1\)</span>、<span class="arithmatex">\(n-2\)</span>、<span class="arithmatex">\(\dots\)</span>、<span class="arithmatex">\(2\)</span>、<span class="arithmatex">\(1\)</span> 次，平均为 <span class="arithmatex">\(n / 2\)</span> 次，因此时间复杂度为 <span class="arithmatex">\(O((n - 1) n / 2) = O(n^2)\)</span> 。</p>
@@ -5461,7 +5461,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n \log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!
</div>
</div>
</div>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_exponential.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="指数阶的时间复杂度" src="../time_complexity.assets/time_complexity_exponential.png" /></a></p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_exponential.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="指数阶的时间复杂度" class="animation-figure" src="../time_complexity.assets/time_complexity_exponential.png" /></a></p>
<p align="center"> 图 2-11 &nbsp; 指数阶的时间复杂度 </p>
<p>在实际算法中，指数阶常出现于递归函数中。例如在以下代码中，其递归地一分为二，经过 <span class="arithmatex">\(n\)</span> 次分裂后停止：</p>
@@ -5727,7 +5727,7 @@ O(1) &lt; O(\log n) &lt; O(n) &lt; O(n \log n) &lt; O(n^2) &lt; O(2^n) &lt; O(n!
</div>
</div>
</div>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_logarithmic.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="对数阶的时间复杂度" src="../time_complexity.assets/time_complexity_logarithmic.png" /></a></p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_logarithmic.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="对数阶的时间复杂度" class="animation-figure" src="../time_complexity.assets/time_complexity_logarithmic.png" /></a></p>
<p align="center"> 图 2-12 &nbsp; 对数阶的时间复杂度 </p>
<p>与指数阶类似，对数阶也常出现于递归函数中。以下代码形成了一个高度为 <span class="arithmatex">\(\log_2 n\)</span> 的递归树：</p>
@@ -6009,7 +6009,7 @@ O(\log_m n) = O(\log_k n / \log_k m) = O(\log_k n)
</div>
</div>
<p>图 2-13 展示了线性对数阶的生成方式。二叉树的每一层的操作总数都为 <span class="arithmatex">\(n\)</span> ，树共有 <span class="arithmatex">\(\log_2 n + 1\)</span> 层，因此时间复杂度为 <span class="arithmatex">\(O(n \log n)\)</span> 。</p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_logarithmic_linear.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="线性对数阶的时间复杂度" src="../time_complexity.assets/time_complexity_logarithmic_linear.png" /></a></p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_logarithmic_linear.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="线性对数阶的时间复杂度" class="animation-figure" src="../time_complexity.assets/time_complexity_logarithmic_linear.png" /></a></p>
<p align="center"> 图 2-13 &nbsp; 线性对数阶的时间复杂度 </p>
<p>主流排序算法的时间复杂度通常为 <span class="arithmatex">\(O(n \log n)\)</span> ，例如快速排序、归并排序、堆排序等。</p>
@@ -6187,7 +6187,7 @@ n! = n \times (n - 1) \times (n - 2) \times \dots \times 2 \times 1
</div>
</div>
</div>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_factorial.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="阶乘阶的时间复杂度" src="../time_complexity.assets/time_complexity_factorial.png" /></a></p>
<p><a class="glightbox" href="../time_complexity.assets/time_complexity_factorial.png" data-type="image" data-width="100%" data-height="auto" data-desc-position="bottom"><img alt="阶乘阶的时间复杂度" class="animation-figure" src="../time_complexity.assets/time_complexity_factorial.png" /></a></p>
<p align="center"> 图 2-14 &nbsp; 阶乘阶的时间复杂度 </p>
<p>请注意，因为当 <span class="arithmatex">\(n \geq 4\)</span> 时恒有 <span class="arithmatex">\(n! &gt; 2^n\)</span> ，所以阶乘阶比指数阶增长得更快，在 <span class="arithmatex">\(n\)</span> 较大时也是不可接受的。</p>