Add Dart codes to the documents. (#529)

docs/chapter_computational_complexity/space_complexity.md

@@ -258,6 +258,12 @@
 
     ```
 
+=== "Dart"
+
+    ```dart title=""
+
+    ```
+
 ## 推算方法
 
 空间复杂度的推算方法与时间复杂度大致相同，只是将统计对象从“计算操作数量”转为“使用空间大小”。与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**，这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
@@ -380,6 +386,12 @@
 
     ```
 
+=== "Dart"
+
+    ```dart title=""
+
+    ```
+
 **在递归函数中，需要注意统计栈帧空间**。例如，函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
 
 === "Java"
@@ -579,6 +591,12 @@
 
     ```
 
+=== "Dart"
+
+    ```dart title=""
+
+    ```
+
 ## 常见类型
 
 设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
@@ -662,6 +680,12 @@ $$
     [class]{}-[func]{constant}
     ```
 
+=== "Dart"
+
+    ```dart title="space_complexity.dart"
+    [class]{}-[func]{constant}
+    ```
+
 ### 线性阶 $O(n)$
 
 线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
@@ -728,6 +752,12 @@ $$
     [class]{}-[func]{linear}
     ```
 
+=== "Dart"
+
+    ```dart title="space_complexity.dart"
+    [class]{}-[func]{linear}
+    ```
+
 以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
 
 === "Java"
@@ -790,6 +820,12 @@ $$
     [class]{}-[func]{linearRecur}
     ```
 
+=== "Dart"
+
+    ```dart title="space_complexity.dart"
+    [class]{}-[func]{linearRecur}
+    ```
+
 ![递归函数产生的线性阶空间复杂度](space_complexity.assets/space_complexity_recursive_linear.png)
 
 ### 平方阶 $O(n^2)$
@@ -856,6 +892,12 @@ $$
     [class]{}-[func]{quadratic}
     ```
 
+=== "Dart"
+
+    ```dart title="space_complexity.dart"
+    [class]{}-[func]{quadratic}
+    ```
+
 在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体占用 $O(n^2)$ 空间。
 
 === "Java"
@@ -918,6 +960,12 @@ $$
     [class]{}-[func]{quadraticRecur}
     ```
 
+=== "Dart"
+
+    ```dart title="space_complexity.dart"
+    [class]{}-[func]{quadraticRecur}
+    ```
+
 ![递归函数产生的平方阶空间复杂度](space_complexity.assets/space_complexity_recursive_quadratic.png)
 
 ### 指数阶 $O(2^n)$
@@ -984,6 +1032,12 @@ $$
     [class]{}-[func]{buildTree}
     ```
 
+=== "Dart"
+
+    ```dart title="space_complexity.dart"
+    [class]{}-[func]{buildTree}
+    ```
+
 ![满二叉树产生的指数阶空间复杂度](space_complexity.assets/space_complexity_exponential.png)
 
 ### 对数阶 $O(\log n)$

docs/chapter_computational_complexity/time_complexity.md

@@ -155,6 +155,12 @@ $$
 
     ```
 
+=== "Dart"
+
+    ```dart title=""
+
+    ```
+
 然而实际上，**统计算法的运行时间既不合理也不现实**。首先，我们不希望预估时间和运行平台绑定，因为算法需要在各种不同的平台上运行。其次，我们很难获知每种操作的运行时间，这给预估过程带来了极大的难度。
 
 ## 统计时间增长趋势
@@ -365,6 +371,12 @@ $$
 
     ```
 
+=== "Dart"
+
+    ```dart title=""
+
+    ```
+
 ![算法 A, B, C 的时间增长趋势](time_complexity.assets/time_complexity_simple_example.png)
 
 相较于直接统计算法运行时间，时间复杂度分析有哪些优势和局限性呢？
@@ -515,6 +527,12 @@ $$
 
     ```
 
+=== "Dart"
+
+    ```dart title=""
+
+    ```
+
 $T(n)$ 是一次函数，说明时间增长趋势是线性的，因此可以得出时间复杂度是线性阶。
 
 我们将线性阶的时间复杂度记为 $O(n)$ ，这个数学符号称为「大 $O$ 记号 Big-$O$ Notation」，表示函数 $T(n)$ 的「渐近上界 Asymptotic Upper Bound」。
@@ -739,6 +757,12 @@ $$
 
     ```
 
+=== "Dart"
+
+    ```dart title=""
+
+    ```
+
 ### 2) 判断渐近上界
 
 **时间复杂度由多项式 $T(n)$ 中最高阶的项来决定**。这是因为在 $n$ 趋于无穷大时，最高阶的项将发挥主导作用，其他项的影响都可以被忽略。
@@ -840,6 +864,12 @@ $$
     [class]{}-[func]{constant}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{constant}
+    ```
+
 ### 线性阶 $O(n)$
 
 线性阶的操作数量相对于输入数据大小以线性级别增长。线性阶通常出现在单层循环中。
@@ -904,6 +934,12 @@ $$
     [class]{}-[func]{linear}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{linear}
+    ```
+
 遍历数组和遍历链表等操作的时间复杂度均为 $O(n)$ ，其中 $n$ 为数组或链表的长度。
 
 !!! question "如何确定输入数据大小 $n$ ？"
@@ -970,6 +1006,12 @@ $$
     [class]{}-[func]{arrayTraversal}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{arrayTraversal}
+    ```
+
 ### 平方阶 $O(n^2)$
 
 平方阶的操作数量相对于输入数据大小以平方级别增长。平方阶通常出现在嵌套循环中，外层循环和内层循环都为 $O(n)$ ，因此总体为 $O(n^2)$ 。
@@ -1034,6 +1076,12 @@ $$
     [class]{}-[func]{quadratic}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{quadratic}
+    ```
+
 ![常数阶、线性阶、平方阶的时间复杂度](time_complexity.assets/time_complexity_constant_linear_quadratic.png)
 
 以「冒泡排序」为例，外层循环执行 $n - 1$ 次，内层循环执行 $n-1, n-2, \cdots, 2, 1$ 次，平均为 $\frac{n}{2}$ 次，因此时间复杂度为 $O(n^2)$ 。
@@ -1102,6 +1150,12 @@ $$
     [class]{}-[func]{bubbleSort}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{bubbleSort}
+    ```
+
 ### 指数阶 $O(2^n)$
 
 !!! note
@@ -1170,6 +1224,12 @@ $$
     [class]{}-[func]{exponential}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{exponential}
+    ```
+
 ![指数阶的时间复杂度](time_complexity.assets/time_complexity_exponential.png)
 
 在实际算法中，指数阶常出现于递归函数。例如以下代码，不断地一分为二，经过 $n$ 次分裂后停止。
@@ -1234,6 +1294,12 @@ $$
     [class]{}-[func]{expRecur}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{expRecur}
+    ```
+
 ### 对数阶 $O(\log n)$
 
 与指数阶相反，对数阶反映了“每轮缩减到一半的情况”。对数阶仅次于常数阶，时间增长缓慢，是理想的时间复杂度。
@@ -1302,6 +1368,12 @@ $$
     [class]{}-[func]{logarithmic}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{logarithmic}
+    ```
+
 ![对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic.png)
 
 与指数阶类似，对数阶也常出现于递归函数。以下代码形成了一个高度为 $\log_2 n$ 的递归树。
@@ -1366,6 +1438,12 @@ $$
     [class]{}-[func]{logRecur}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{logRecur}
+    ```
+
 ### 线性对数阶 $O(n \log n)$
 
 线性对数阶常出现于嵌套循环中，两层循环的时间复杂度分别为 $O(\log n)$ 和 $O(n)$ 。
@@ -1432,6 +1510,12 @@ $$
     [class]{}-[func]{linearLogRecur}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{linearLogRecur}
+    ```
+
 ![线性对数阶的时间复杂度](time_complexity.assets/time_complexity_logarithmic_linear.png)
 
 ### 阶乘阶 $O(n!)$
@@ -1504,6 +1588,12 @@ $$
     [class]{}-[func]{factorialRecur}
     ```
 
+=== "Dart"
+
+    ```dart title="time_complexity.dart"
+    [class]{}-[func]{factorialRecur}
+    ```
+
 ![阶乘阶的时间复杂度](time_complexity.assets/time_complexity_factorial.png)
 
 ## 最差、最佳、平均时间复杂度
@@ -1614,6 +1704,14 @@ $$
     }
     ```
 
+=== "Dart"
+
+    ```dart title="worst_best_time_complexity.dart"
+    [class]{}-[func]{randomNumbers}
+
+    [class]{}-[func]{findOne}
+    ```
+
 !!! tip
 
     实际应用中我们很少使用「最佳时间复杂度」，因为通常只有在很小概率下才能达到，可能会带来一定的误导性。相反，「最差时间复杂度」更为实用，因为它给出了一个“效率安全值”，让我们可以放心地使用算法。