Several bug fixes and improments.

weiplanet · Sep 24, 2023 · e3773b7 · e3773b7
1 parent 0f0892b
commit e3773b7
Show file tree

Hide file tree

Showing 16 changed files with 17 additions and 15 deletions.
diff --git a/codes/cpp/chapter_hashing/hash_map_open_addressing.cpp b/codes/cpp/chapter_hashing/hash_map_open_addressing.cpp
@@ -6,6 +6,7 @@
 
 #include "./array_hash_map.cpp"
 
+/* 开放寻址哈希表 */
 class HashMapOpenAddressing {
   private:
     int size;                             // 键值对数量

diff --git a/codes/go/chapter_hashing/hash_map_open_addressing.go b/codes/go/chapter_hashing/hash_map_open_addressing.go
@@ -9,7 +9,7 @@ import (
 	"strconv"
 )
 
-/* 链式地址哈希表 */
+/* 开放寻址哈希表 */
 type hashMapOpenAddressing struct {
 	size        int     // 键值对数量
 	capacity    int     // 哈希表容量

diff --git a/codes/javascript/chapter_computational_complexity/recursion.js b/codes/javascript/chapter_computational_complexity/recursion.js
@@ -14,7 +14,7 @@ function recur(n) {
     return n + res;
 }
 
-/* 递归转化为迭代 */
+/* 使用迭代模拟递归 */
 function forLoopRecur(n) {
     // 使用一个显式的栈来模拟系统调用栈
     const stack = [];
@@ -59,7 +59,7 @@ res = recur(n);
 console.log(`递归函数的求和结果 res = ${res}`);
 
 res = forLoopRecur(n);
-console.log(`递归转化为迭代的求和结果 res = ${res}`);
+console.log(`使用迭代模拟递归的求和结果 res = ${res}`);
 
 res = tailRecur(n, 0);
 console.log(`尾递归函数的求和结果 res = ${res}`);

diff --git a/codes/typescript/chapter_computational_complexity/recursion.ts b/codes/typescript/chapter_computational_complexity/recursion.ts
@@ -14,7 +14,7 @@ function recur(n: number): number {
     return n + res;
 }
 
-/* 递归转化为迭代 */
+/* 使用迭代模拟递归 */
 function forLoopRecur(n: number): number {
     // 使用一个显式的栈来模拟系统调用栈 
     const stack: number[] = [];
@@ -59,7 +59,7 @@ res = recur(n);
 console.log(`递归函数的求和结果 res = ${res}`);
 
 res = forLoopRecur(n);
-console.log(`递归转化为迭代的求和结果 res = ${res}`);
+console.log(`使用迭代模拟递归的求和结果 res = ${res}`);
 
 res = tailRecur(n, 0);
 console.log(`尾递归函数的求和结果 res = ${res}`);

diff --git a/docs/chapter_array_and_linkedlist/linked_list.assets/linkedlist_definition.png b/docs/chapter_array_and_linkedlist/linked_list.assets/linkedlist_definition.png
diff --git a/docs/chapter_array_and_linkedlist/linked_list.md b/docs/chapter_array_and_linkedlist/linked_list.md
@@ -717,7 +717,7 @@
 
 |            | 数组                     | 链表         |
 | ---------- | ------------------------ | ------------ |
-| 存储方式   | 连续内存空间             | 离散内存空间 |
+| 存储方式   | 连续内存空间             | 分散内存空间 |
 | 缓存局部性 | 友好                     | 不友好       |
 | 容量扩展   | 长度不可变               | 可灵活扩展   |
 | 内存效率   | 占用内存少、浪费部分空间 | 占用内存多   |

diff --git a/docs/chapter_array_and_linkedlist/summary.md b/docs/chapter_array_and_linkedlist/summary.md
@@ -2,7 +2,7 @@
 
 ### 重点回顾
 
-- 数组和链表是两种基本的数据结构，分别代表数据在计算机内存中的两种存储方式：连续空间存储和离散空间存储。两者的特点呈现出互补的特性。
+- 数组和链表是两种基本的数据结构，分别代表数据在计算机内存中的两种存储方式：连续空间存储和分散空间存储。两者的特点呈现出互补的特性。
 - 数组支持随机访问、占用内存较少；但插入和删除元素效率低，且初始化后长度不可变。
 - 链表通过更改引用（指针）实现高效的节点插入与删除，且可以灵活调整长度；但节点访问效率低、占用内存较多。常见的链表类型包括单向链表、循环链表、双向链表。
 - 动态数组，又称列表，是基于数组实现的一种数据结构。它保留了数组的优势，同时可以灵活调整长度。列表的出现极大地提高了数组的易用性，但可能导致部分内存空间浪费。

diff --git a/...e/classification_of_data_structure.assets/classification_phisical_structure.png b/...e/classification_of_data_structure.assets/classification_phisical_structure.png
diff --git a/docs/chapter_data_structure/classification_of_data_structure.md b/docs/chapter_data_structure/classification_of_data_structure.md
@@ -19,7 +19,7 @@
 - **树形结构**：树、堆、哈希表，元素之间是一对多的关系。
 - **网状结构**：图，元素之间是多对多的关系。
 
-## 物理结构：连续与离散
+## 物理结构：连续与分散
 
 在计算机中，内存和硬盘是两种主要的存储硬件设备。硬盘主要用于长期存储数据，容量较大（通常可达到 TB 级别）、速度较慢。内存用于运行程序时暂存数据，速度较快，但容量较小（通常为 GB 级别）。
 
@@ -29,11 +29,11 @@
 
 ![内存条、内存空间、内存地址](classification_of_data_structure.assets/computer_memory_location.png)
 
-内存是所有程序的共享资源，当某块内存被某个程序占用时，则无法被其他程序同时使用了。**因此在数据结构与算法的设计中，内存资源是一个重要的考虑因素**。比如，算法所占用的内存峰值不应超过系统剩余空闲内存；如果缺少连续大块的内存空间，那么所选用的数据结构必须能够存储在离散的内存空间内。
+内存是所有程序的共享资源，当某块内存被某个程序占用时，则无法被其他程序同时使用了。**因此在数据结构与算法的设计中，内存资源是一个重要的考虑因素**。比如，算法所占用的内存峰值不应超过系统剩余空闲内存；如果缺少连续大块的内存空间，那么所选用的数据结构必须能够存储在分散的内存空间内。
 
-如下图所示，**物理结构反映了数据在计算机内存中的存储方式**，可分为连续空间存储（数组）和离散空间存储（链表）。物理结构从底层决定了数据的访问、更新、增删等操作方法，同时在时间效率和空间效率方面呈现出互补的特点。
+如下图所示，**物理结构反映了数据在计算机内存中的存储方式**，可分为连续空间存储（数组）和分散空间存储（链表）。物理结构从底层决定了数据的访问、更新、增删等操作方法，同时在时间效率和空间效率方面呈现出互补的特点。
 
-![连续空间存储与离散空间存储](classification_of_data_structure.assets/classification_phisical_structure.png)
+![连续空间存储与分散空间存储](classification_of_data_structure.assets/classification_phisical_structure.png)
 
 值得说明的是，**所有数据结构都是基于数组、链表或二者的组合实现的**。例如，栈和队列既可以使用数组实现，也可以使用链表实现；而哈希表的实现可能同时包含数组和链表。
 

diff --git a/docs/chapter_data_structure/summary.md b/docs/chapter_data_structure/summary.md
@@ -5,7 +5,7 @@
 - 数据结构可以从逻辑结构和物理结构两个角度进行分类。逻辑结构描述了数据元素之间的逻辑关系，而物理结构描述了数据在计算机内存中的存储方式。
 - 常见的逻辑结构包括线性、树状和网状等。通常我们根据逻辑结构将数据结构分为线性（数组、链表、栈、队列）和非线性（树、图、堆）两种。哈希表的实现可能同时包含线性和非线性结构。
 - 当程序运行时，数据被存储在计算机内存中。每个内存空间都拥有对应的内存地址，程序通过这些内存地址访问数据。
-- 物理结构主要分为连续空间存储（数组）和离散空间存储（链表）。所有数据结构都是由数组、链表或两者的组合实现的。
+- 物理结构主要分为连续空间存储（数组）和分散空间存储（链表）。所有数据结构都是由数组、链表或两者的组合实现的。
 - 计算机中的基本数据类型包括整数 `byte`、`short`、`int`、`long` ，浮点数 `float`、`double` ，字符 `char` 和布尔 `boolean` 。它们的取值范围取决于占用空间大小和表示方式。
 - 原码、反码和补码是在计算机中编码数字的三种方法，它们之间是可以相互转换的。整数的原码的最高位是符号位，其余位是数字的值。
 - 整数在计算机中是以补码的形式存储的。在补码表示下，计算机可以对正数和负数的加法一视同仁，不需要为减法操作单独设计特殊的硬件电路，并且不存在正负零歧义的问题。

diff --git a/docs/chapter_preface/about_the_book.assets/hello_algo_mindmap.jpg b/docs/chapter_preface/about_the_book.assets/hello_algo_mindmap.jpg
diff --git a/docs/chapter_preface/about_the_book.assets/hello_algo_mindmap.png b/docs/chapter_preface/about_the_book.assets/hello_algo_mindmap.png
diff --git a/docs/chapter_searching/searching_algorithm_revisited.md b/docs/chapter_searching/searching_algorithm_revisited.md
@@ -78,7 +78,7 @@
 
 **树查找**
 
-- 适用于海量数据，因为树节点在内存中是离散存储的。
+- 适用于海量数据，因为树节点在内存中是分散存储的。
 - 适合需要维护有序数据或范围查找的场景。
 - 在持续增删节点的过程中，二叉搜索树可能产生倾斜，时间复杂度劣化至 $O(n)$ 。
 - 若使用 AVL 树或红黑树，则各项操作可在 $O(\log n)$ 效率下稳定运行，但维护树平衡的操作会增加额外开销。
diff --git a/docs/chapter_stack_and_queue/summary.md b/docs/chapter_stack_and_queue/summary.md
@@ -3,7 +3,7 @@
 ### 重点回顾
 
 - 栈是一种遵循先入后出原则的数据结构，可通过数组或链表来实现。
-- 从时间效率角度看，栈的数组实现具有较高的平均效率，但在扩容过程中，单次入栈操作的时间复杂度会降低至 $O(n)$ 。相比之下，基于链表实现的栈具有更为稳定的效率表现。
+- 从时间效率角度看，栈的数组实现具有较高的平均效率，但在扩容过程中，单次入栈操作的时间复杂度会劣化至 $O(n)$ 。相比之下，基于链表实现的栈具有更为稳定的效率表现。
 - 在空间效率方面，栈的数组实现可能导致一定程度的空间浪费。但需要注意的是，链表节点所占用的内存空间比数组元素更大。
 - 队列是一种遵循先入先出原则的数据结构，同样可以通过数组或链表来实现。在时间效率和空间效率的对比上，队列的结论与前述栈的结论相似。
 - 双向队列是一种具有更高自由度的队列，它允许在两端进行元素的添加和删除操作。

diff --git a/docs/index.md b/docs/index.md
@@ -1,5 +1,6 @@
 ---
 comments: true
+glightbox: false
 hide:
   - footer
 ---

diff --git a/docs/stylesheets/extra.css b/docs/stylesheets/extra.css
@@ -25,7 +25,7 @@
   --md-default-fg-color: #adbac7;
   --md-default-bg-color: #22272e;
 
-  --md-code-bg-color: #2D333B;
+  --md-code-bg-color: #1D2126;
   --md-code-fg-color: #adbac7;
 
   --md-accent-fg-color: #aaa;