Release Rust code to documents. (#656)

docs/chapter_hashing/hash_algorithm.md

@@ -177,6 +177,18 @@ index = hash(key) % capacity
     [class]{}-[func]{rot_hash}
     ```
 
+=== "Rust"
+
+    ```rust title="simple_hash.rs"
+    [class]{}-[func]{add_hash}
+
+    [class]{}-[func]{mul_hash}
+
+    [class]{}-[func]{xor_hash}
+
+    [class]{}-[func]{rot_hash}
+    ```
+
 观察发现，每种哈希算法的最后一步都是对大质数 $1000000007$ 取模，以确保哈希值在合适的范围内。值得思考的是，为什么要强调对质数取模，或者说对合数取模的弊端是什么？这是一个有趣的问题。
 
 先抛出结论：**当我们使用大质数作为模数时，可以最大化地保证哈希值的均匀分布**。因为质数不会与其他数字存在公约数，可以减少因取模操作而产生的周期性模式，从而避免哈希冲突。
@@ -431,6 +443,12 @@ $$
     // 节点对象 Instance of 'ListNode' 的哈希值为 1033450432
     ```
 
+=== "Rust"
+
+    ```rust title="built_in_hash.rs"
+
+    ```
+
 在许多编程语言中，**只有不可变对象才可作为哈希表的 `key`** 。假如我们将列表（动态数组）作为 `key` ，当列表的内容发生变化时，它的哈希值也随之改变，我们就无法在哈希表中查询到原先的 `value` 了。
 
 虽然自定义对象（比如链表节点）的成员变量是可变的，但它是可哈希的。**这是因为对象的哈希值通常是基于内存地址生成的**，即使对象的内容发生了变化，但它的内存地址不变，哈希值仍然是不变的。

docs/chapter_hashing/hash_collision.md

@@ -97,6 +97,12 @@
     [class]{HashMapChaining}-[func]{}
     ```
 
+=== "Rust"
+
+    ```rust title="hash_map_chaining.rs"
+    [class]{HashMapChaining}-[func]{}
+    ```
+
 !!! tip
 
     当链表很长时，查询效率 $O(n)$ 很差，**此时可以将链表转换为「AVL 树」或「红黑树」**，从而将查询操作的时间复杂度优化至 $O(\log n)$ 。
@@ -190,6 +196,12 @@
     [class]{HashMapOpenAddressing}-[func]{}
     ```
 
+=== "Rust"
+
+    ```rust title="hash_map_open_addressing.rs"
+    [class]{HashMapOpenAddressing}-[func]{}
+    ```
+
 ### 多次哈希
 
 顾名思义，多次哈希方法是使用多个哈希函数 $f_1(x)$ , $f_2(x)$ , $f_3(x)$ , $\cdots$ 进行探测。

docs/chapter_hashing/hash_map.md

@@ -250,6 +250,12 @@
     map.remove(10583);
     ```
 
+=== "Rust"
+
+    ```rust title="hash_map.rs"
+
+    ```
+
 哈希表有三种常用遍历方式：遍历键值对、遍历键和遍历值。
 
 === "Java"
@@ -425,6 +431,12 @@
     });
     ```
 
+=== "Rust"
+
+    ```rust title="hash_map.rs"
+
+    ```
+
 ## 哈希表简单实现
 
 我们先考虑最简单的情况，**仅用一个数组来实现哈希表**。在哈希表中，我们将数组中的每个空位称为「桶 Bucket」，每个桶可存储一个键值对。因此，查询操作就是找到 `key` 对应的桶，并在桶中获取 `value` 。
@@ -545,6 +557,14 @@ index = hash(key) % capacity
     [class]{ArrayHashMap}-[func]{}
     ```
 
+=== "Rust"
+
+    ```rust title="array_hash_map.rs"
+    [class]{Pair}-[func]{}
+
+    [class]{ArrayHashMap}-[func]{}
+    ```
+
 ## 哈希冲突与扩容
 
 本质上看，哈希函数的作用是将所有 `key` 构成的输入空间映射到数组所有索引构成的输出空间，而输入空间往往远大于输出空间。因此，**理论上一定存在“多个输入对应相同输出”的情况**。