finetune

docs/chapter_array_and_linkedlist/array.md

@@ -114,12 +114,7 @@
 
 ### 访问元素
 
-数组元素被存储在连续的内存空间中，这意味着计算数组元素的内存地址非常容易。给定数组内存地址（即首元素内存地址）和某个元素的索引，我们可以使用以下公式计算得到该元素的内存地址，从而直接访问此元素。
-
-```shell
-# 元素内存地址 = 数组内存地址（首元素内存地址） + 元素长度 * 元素索引
-elementAddr = firtstElementAddr + elementLength * elementIndex
-```
+数组元素被存储在连续的内存空间中，这意味着计算数组元素的内存地址非常容易。给定数组内存地址（即首元素内存地址）和某个元素的索引，我们可以使用下图所示的公式计算得到该元素的内存地址，从而直接访问此元素。
 
 ![数组元素的内存地址计算](array.assets/array_memory_location_calculation.png)
 

docs/chapter_array_and_linkedlist/summary.md

@@ -21,11 +21,10 @@
 
     链表由结点组成，结点之间通过引用（指针）连接，各个结点可以存储不同类型的数据，例如 int、double、string、object 等。
 
-    相对地，数组元素则必须是相同类型的，这样才能通过计算偏移量来获取对应元素位置。例如，如果数组同时包含 int 和 long 两种类型，单个元素分别占用 4 bytes 和 8 bytes ，那么此时就不能用以下公式计算偏移量了，因为数组中包含了两种 `elementLength` 。
+    相对地，数组元素则必须是相同类型的，这样才能通过计算偏移量来获取对应元素位置。例如，如果数组同时包含 int 和 long 两种类型，单个元素分别占用 4 bytes 和 8 bytes ，那么此时就不能用以下公式计算偏移量了，因为数组中包含了两种长度的元素。
 
-    ```
-    // 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
-    elementAddr = firtstElementAddr + elementLength * elementIndex
+    ```shell
+    # 元素内存地址 = 数组内存地址 + 元素长度 * 元素索引
     ```
 
 !!! question "删除节点后，是否需要把 `P.next` 设为 $\text{None}$ 呢？"

docs/chapter_hashing/hash_algorithm.md

@@ -223,12 +223,14 @@ $$
 
 在实际中，我们通常会用一些标准哈希算法，例如 MD5、SHA-1、SHA-2、SHA3 等。它们可以将任意长度的输入数据映射到恒定长度的哈希值。
 
-近一个世纪以来，哈希算法处在不断升级与优化的过程中。一部分研究人员努力提升哈希算法的性能，另一部分研究人员和黑客则致力于寻找哈希算法的安全性问题。
+近一个世纪以来，哈希算法处在不断升级与优化的过程中。一部分研究人员努力提升哈希算法的性能，另一部分研究人员和黑客则致力于寻找哈希算法的安全性问题。下表展示了在实际应用中常见的哈希算法。
 
 - MD5 和 SHA-1 已多次被成功攻击，因此它们被各类安全应用弃用。
 - SHA-2 系列中的 SHA-256 是最安全的哈希算法之一，仍未出现成功的攻击案例，因此常被用在各类安全应用与协议中。
 - SHA-3 相较 SHA-2 的实现开销更低、计算效率更高，但目前使用覆盖度不如 SHA-2 系列。
 
+<p align="center"> 表 <id> &nbsp; 常见的哈希算法 </p>
+
 |          | MD5                            | SHA-1            | SHA-2                        | SHA-3                |
 | -------- | ------------------------------ | ---------------- | ---------------------------- | -------------------- |
 | 推出时间 | 1992                           | 1995             | 2002                         | 2008                 |

docs/chapter_stack_and_queue/queue.md

@@ -378,12 +378,12 @@
 
 由于数组删除首元素的时间复杂度为 $O(n)$ ，这会导致出队操作效率较低。然而，我们可以采用以下巧妙方法来避免这个问题。
 
-我们可以使用一个变量 `front` 指向队首元素的索引，并维护一个变量 `queSize` 用于记录队列长度。定义 `rear = front + queSize` ，这个公式计算出的 `rear` 指向队尾元素之后的下一个位置。
+我们可以使用一个变量 `front` 指向队首元素的索引，并维护一个变量 `size` 用于记录队列长度。定义 `rear = front + size` ，这个公式计算出的 `rear` 指向队尾元素之后的下一个位置。
 
 基于此设计，**数组中包含元素的有效区间为 `[front, rear - 1]`**，各种操作的实现方法如下图所示。
 
-- 入队操作：将输入元素赋值给 `rear` 索引处，并将 `queSize` 增加 1 。
-- 出队操作：只需将 `front` 增加 1 ，并将 `queSize` 减少 1 。
+- 入队操作：将输入元素赋值给 `rear` 索引处，并将 `size` 增加 1 。
+- 出队操作：只需将 `front` 增加 1 ，并将 `size` 减少 1 。
 
 可以看到，入队和出队操作都只需进行一次操作，时间复杂度均为 $O(1)$ 。
 

docs/chapter_tree/binary_search_tree.md

@@ -60,7 +60,7 @@
 === "JS"
 
     ```javascript title="binary_search_tree.js"
-    [class]{}-[func]{search}
+    [class]{BinarySearchTree}-[func]{search}
     ```
 
 === "TS"
@@ -146,7 +146,7 @@
 === "JS"
 
     ```javascript title="binary_search_tree.js"
-    [class]{}-[func]{insert}
+    [class]{BinarySearchTree}-[func]{insert}
     ```
 
 === "TS"
@@ -257,7 +257,7 @@
 === "JS"
 
     ```javascript title="binary_search_tree.js"
-    [class]{}-[func]{remove}
+    [class]{BinarySearchTree}-[func]{remove}
     ```
 
 === "TS"