build

chapter_computational_complexity/space_complexity.md

@@ -286,6 +286,12 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 ## 2.3.2.   推算方法
 
 空间复杂度的推算方法与时间复杂度大致相同，只是将统计对象从“计算操作数量”转为“使用空间大小”。与时间复杂度不同的是，**我们通常只关注「最差空间复杂度」**，这是因为内存空间是一项硬性要求，我们必须确保在所有输入数据下都有足够的内存空间预留。
@@ -418,6 +424,12 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 **在递归函数中，需要注意统计栈帧空间**。例如，函数 `loop()` 在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行过程中会同时存在 $n$ 个未返回的 `recur()` ，从而占用 $O(n)$ 的栈帧空间。
 
 === "Java"
@@ -633,6 +645,12 @@ comments: true
     }
     ```
 
+=== "Rust"
+
+    ```rust title=""
+
+    ```
+
 ## 2.3.3.   常见类型
 
 设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
@@ -895,6 +913,28 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    /* 常数阶 */
+    #[allow(unused)]
+    fn constant(n: i32) {
+        // 常量、变量、对象占用 O(1) 空间
+        const A: i32 = 0;
+        let b = 0;
+        let nums = vec![0; 10000];
+        let node = ListNode::new(0);
+        // 循环中的变量占用 O(1) 空间
+        for i in 0..n {
+            let c = 0;
+        }
+        // 循环中的函数占用 O(1) 空间
+        for i in 0..n {
+            function();
+        }
+    }
+    ```
+
 ### 线性阶 $O(n)$
 
 线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
@@ -1140,6 +1180,27 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    /* 线性阶 */
+    #[allow(unused)]
+    fn linear(n: i32) {
+        // 长度为 n 的数组占用 O(n) 空间
+        let mut nums = vec![0; n as usize];
+        // 长度为 n 的列表占用 O(n) 空间
+        let mut nodes = Vec::new();
+        for i in 0..n {
+            nodes.push(ListNode::new(i))
+        }
+        // 长度为 n 的哈希表占用 O(n) 空间
+        let mut map = HashMap::new();
+        for i in 0..n {
+            map.insert(i, i.to_string());
+        }
+    }
+    ```
+
 以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
 
 === "Java"
@@ -1270,6 +1331,17 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    /* 线性阶（递归实现） */
+    fn linear_recur(n: i32) {
+        println!("递归 n = {}", n);
+        if n == 1 {return};
+        linear_recur(n - 1);
+    }
+    ```
+
 ![递归函数产生的线性阶空间复杂度](space_complexity.assets/space_complexity_recursive_linear.png)
 
 <p align="center"> Fig. 递归函数产生的线性阶空间复杂度 </p>
@@ -1471,6 +1543,26 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    /* 平方阶 */
+    #[allow(unused)]
+    fn quadratic(n: i32) {
+        // 矩阵占用 O(n^2) 空间
+        let num_matrix = vec![vec![0; n as usize]; n as usize];
+        // 二维列表占用 O(n^2) 空间
+        let mut num_list = Vec::new();
+        for i in 0..n {
+            let mut tmp = Vec::new();
+            for j in 0..n {
+                tmp.push(0);
+            }
+            num_list.push(tmp);
+        }
+    }
+    ```
+
 在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体占用 $O(n^2)$ 空间。
 
 === "Java"
@@ -1617,6 +1709,19 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    /* 平方阶（递归实现） */
+    fn quadratic_recur(n: i32) -> i32 {
+        if n <= 0 {return 0};
+        // 数组 nums 长度为 n, n-1, ..., 2, 1
+        let nums = vec![0; n as usize];
+        println!("递归 n = {} 中的 nums 长度 = {}", n, nums.len());
+        return quadratic_recur(n - 1);
+    }
+    ```
+
 ![递归函数产生的平方阶空间复杂度](space_complexity.assets/space_complexity_recursive_quadratic.png)
 
 <p align="center"> Fig. 递归函数产生的平方阶空间复杂度 </p>
@@ -1776,6 +1881,19 @@ $$
     }
     ```
 
+=== "Rust"
+
+    ```rust title="space_complexity.rs"
+    /* 指数阶（建立满二叉树） */
+    fn build_tree(n: i32) -> Option<Rc<RefCell<TreeNode>>> {
+        if n == 0 {return None};
+        let root = TreeNode::new(0);
+        root.borrow_mut().left = build_tree(n - 1);
+        root.borrow_mut().right = build_tree(n - 1);
+        return Some(root);
+    }
+    ```
+
 ![满二叉树产生的指数阶空间复杂度](space_complexity.assets/space_complexity_exponential.png)
 
 <p align="center"> Fig. 满二叉树产生的指数阶空间复杂度 </p>