Update hash map and hash collision.

docs/chapter_hashing/hash_collision.md

@@ -13,7 +13,7 @@ comments: true
 - 哈希表的桶的大小（地址范围）是有限的，只要数据量足够大，理论上一定会出现冲突；
 - 哈希函数很难使键值对完全均匀分布，这也增大了冲突发生的可能性。
 
-哈希冲突的常见的解决方案有「链式地址」和「开放寻址」。
+虽然理论上哈希冲突无法避免，但我们仍然可以在数据结构与算法的层面缓解冲突问题，尽量保证哈希表的增删查改操作效率。**常见的哈希冲突的解决方案有「链式地址」和「开放寻址」**。
 
 ## 链式地址
 

docs/chapter_hashing/hash_map.md

@@ -37,44 +37,132 @@ comments: true
 
 哈希表的基本操作包括 **初始化、查询操作、添加与删除键值对**。
 
-```java title="hash_map.java"
+=== "Java"
-/* 初始化哈希表 */
-Map<Integer, String> map = new HashMap<>();
 
-/* 添加操作 */
+    ```java title="hash_map.java"
-// 在哈希表中添加键值对 (key, value)
+    /* 初始化哈希表 */
-map.put(12836, "小哈");   
+    Map<Integer, String> map = new HashMap<>();
-map.put(15937, "小啰");   
-map.put(16750, "小算");   
-map.put(13276, "小法");
-map.put(10583, "小鸭");
 
-/* 查询操作 */
+    /* 添加操作 */
-// 向哈希表输入键 key ，得到值 value
+    // 在哈希表中添加键值对 (key, value)
-String name = map.get(15937);
+    map.put(12836, "小哈");   
+    map.put(15937, "小啰");   
+    map.put(16750, "小算");   
+    map.put(13276, "小法");
+    map.put(10583, "小鸭");
 
-/* 删除操作 */
+    /* 查询操作 */
-// 在哈希表中删除键值对 (key, value)
+    // 向哈希表输入键 key ，得到值 value
-map.remove(10583);
+    String name = map.get(15937);
-```
+
+    /* 删除操作 */
+    // 在哈希表中删除键值对 (key, value)
+    map.remove(10583);
+    ```
+
+=== "C++"
+
+    ```cpp title="hash_map.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="hash_map.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="hash_map.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="hash_map.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="hash_map.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="hash_map.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="hash_map.cs"
+
+    ```
 
 遍历哈希表有三种方式，即 **遍历键值对、遍历键、遍历值**。
 
-```java
+=== "Java"
-/* 遍历哈希表 */
+
-// 遍历键值对 key->value
+    ```java title="hash_map.java"
-for (Map.Entry <Integer, String> kv: map.entrySet()) {
+    /* 遍历哈希表 */
-    System.out.println(kv.getKey() + " -> " + kv.getValue());
+    // 遍历键值对 key->value
-}
+    for (Map.Entry <Integer, String> kv: map.entrySet()) {
-// 单独遍历键 key
+        System.out.println(kv.getKey() + " -> " + kv.getValue());
-for (int key: map.keySet()) {
+    }
-    System.out.println(key);
+    // 单独遍历键 key
-}
+    for (int key: map.keySet()) {
-// 单独遍历值 value
+        System.out.println(key);
-for (String val: map.values()) {
+    }
-    System.out.println(val);
+    // 单独遍历值 value
-}
+    for (String val: map.values()) {
-```
+        System.out.println(val);
+    }
+    ```
+
+=== "C++"
+
+    ```cpp title="hash_map.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="hash_map.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="hash_map.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="hash_map.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="hash_map.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="hash_map.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="hash_map.cs"
+
+    ```
 
 ## 哈希函数
 
@@ -97,57 +185,101 @@ $$
 
 <p align="center"> Fig. 哈希函数 </p>
 
-```java title="array_hash_map.java"
+=== "Java"
-/* 键值对 int->String */
-class Entry {
-    public int key;     // 键
-    public String val;  // 值
-    public Entry(int key, String val) {
-        this.key = key;
-        this.val = val;
-    }
-}
 
-/* 基于数组简易实现的哈希表 */
+    ```java title="array_hash_map.java"
-class ArrayHashMap {
+    /* 键值对 int->String */
-    private List<Entry> bucket;
+    class Entry {
-    public ArrayHashMap() {
+        public int key;     // 键
-        // 初始化一个长度为 100 的桶（数组）
+        public String val;  // 值
-        bucket = new ArrayList<>();
+        public Entry(int key, String val) {
-        for (int i = 0; i < 100; i++) {
+            this.key = key;
-            bucket.add(null);
+            this.val = val;
         }
     }
 
-    /* 哈希函数 */
+    /* 基于数组简易实现的哈希表 */
-    private int hashFunc(int key) {
+    class ArrayHashMap {
-        int index = key % 100;
+        private List<Entry> bucket;
-        return index;
+        public ArrayHashMap() {
-    }
+            // 初始化一个长度为 100 的桶（数组）
+            bucket = new ArrayList<>();
+            for (int i = 0; i < 100; i++) {
+                bucket.add(null);
+            }
+        }
 
-    /* 查询操作 */
+        /* 哈希函数 */
-    public String get(int key) {
+        private int hashFunc(int key) {
-        int index = hashFunc(key);
+            int index = key % 100;
-        Entry pair = bucket.get(index);
+            return index;
-        if (pair == null) return null;
+        }
-        return pair.val;
-    }
 
-    /* 添加操作 */
+        /* 查询操作 */
-    public void put(int key, String val) {
+        public String get(int key) {
-        Entry pair = new Entry(key, val);
+            int index = hashFunc(key);
-        int index = hashFunc(key);
+            Entry pair = bucket.get(index);
-        bucket.set(index, pair);
+            if (pair == null) return null;
-    }
+            return pair.val;
+        }
 
-    /* 删除操作 */
+        /* 添加操作 */
-    public void remove(int key) {
+        public void put(int key, String val) {
-        int index = hashFunc(key);
+            Entry pair = new Entry(key, val);
-        // 置为空字符，代表删除
+            int index = hashFunc(key);
-        bucket.set(index, null);
+            bucket.set(index, pair);
+        }
+
+        /* 删除操作 */
+        public void remove(int key) {
+            int index = hashFunc(key);
+            // 置为空字符，代表删除
+            bucket.set(index, null);
+        }
     }
-}
+    ```
-```
+
+=== "C++"
+
+    ```cpp title="array_hash_map.cpp"
+
+    ```
+
+=== "Python"
+
+    ```python title="array_hash_map.py"
+
+    ```
+
+=== "Go"
+
+    ```go title="array_hash_map.go"
+
+    ```
+
+=== "JavaScript"
+
+    ```js title="array_hash_map.js"
+
+    ```
+
+=== "TypeScript"
+
+    ```typescript title="array_hash_map.ts"
+
+    ```
+
+=== "C"
+
+    ```c title="array_hash_map.c"
+
+    ```
+
+=== "C#"
+
+    ```csharp title="array_hash_map.cs"
+
+    ```
 
 ## 哈希冲突
 

docs/chapter_introduction/what_is_dsa.md

@@ -37,6 +37,6 @@ comments: true
 
 <p align="center"> Fig. 数据结构与算法的关系 </p>
 
-!!! tip "约定俗成的习惯"
+!!! tip "约定俗成的简称"
 
-    在实际讨论中，我们通常会将「数据结构与算法」简称为「算法」。例如，我们熟称的 LeetCode 算法题目，实际上同时考察了数据结构和算法两部分知识。
+    在实际讨论中，我们通常会将「数据结构与算法」直接简称为「算法」。例如，我们熟称的 LeetCode 算法题目，实际上同时考察了数据结构和算法两部分知识。

docs/chapter_preface/about_the_book.md

@@ -115,7 +115,7 @@ comments: true
 
 - 感谢我的女朋友泡泡担任本书的首位读者，从算法小白的视角为本书的写作提出了许多建议，使这本书更加适合算法初学者来阅读。
 - 感谢腾宝、琦宝、飞宝为本书起了个响当当的名字，好听又有梗，直接唤起我最初敲下第一行代码 "Hello, World!" 的回忆。
-- 感谢我的导师李博，在小酌畅谈时你告诉我 “想做就去做” ，坚定了我写这本书的决心。
+- 感谢我的导师李博，在小酌畅谈时您告诉我 “觉得适合、想做就去做” ，坚定了我写这本书的决心。
 - 感谢苏潼为本书设计了封面和 LOGO ，我有些强迫症，前后多次修改，谢谢你的耐心。
 - 感谢 @squidfunk ，包括 [Material-for-MkDocs](https://github.com/squidfunk/mkdocs-material/tree/master) 顶级开源项目以及给出的写作排版建议。
 

docs/chapter_preface/suggestions.md

@@ -12,11 +12,11 @@ comments: true
 
 ![algorithm_animation](suggestions.assets/algorithm_animation.gif)
 
-## 使用源代码
+## 代码实践学
 
 !!! tip "前置工作"
 
-    安装本地编程环境。若无，可以参照下节 [编程环境安装](https://www.hello-algo.com/chapter_preface/installation/) 。
+    如果没有本地编程环境，可以参照下节 [编程环境安装](https://www.hello-algo.com/chapter_preface/installation/) 。
 
 ### 下载代码仓
 
@@ -36,17 +36,17 @@ git clone https://github.com/krahets/hello-algo.git
 
 ![code_md_to_repo](suggestions.assets/code_md_to_repo.png)
 
-这些源文件中包含测试样例，可以直接运行，帮助你省去不必要的调试时间，可以将精力集中在学习内容上。
+这些源文件中包含详细注释，配有测试样例，可以直接运行，帮助你省去不必要的调试时间，可以将精力集中在学习内容上。
-
-!!! tip "代码学习建议"
-
-    若学习时间紧张，请至少 **将所有代码通读并运行一遍**。若时间允许，强力建议 **对照着代码自己敲一遍**，逐渐锻炼肌肉记忆。相比于读代码，自己写的过程会带来新的收获。
 
 ![running_code](suggestions.assets/running_code.gif)
 
-## 参与讨论区
+!!! tip "代码学习建议"
 
-阅读本书时，请不要 “惯着” 那些弄不明白的知识点。如果有任何疑惑，可以在评论区留下你的问题，小伙伴们和我都会给予解答（我一般 2 ~ 3 天看一次评论区）。
+    若学习时间紧张，**请至少将所有代码通读并运行一遍**。若时间允许，**强烈建议对照着代码自己敲一遍**，逐渐锻炼肌肉记忆。相比于读代码，写代码的过程往往能带来新的收获。
+
+## 提问讨论学
+
+阅读本书时，请不要 “惯着” 那些弄不明白的知识点。如果有任何疑惑，**可以在评论区留下你的问题**，小伙伴们和我都会给予解答（您一般 3 天内会得到回复）。
 
 同时，也希望你可以多花时间逛逛评论区。一方面，可以看看大家遇到了什么问题，反过来查漏补缺，这往往可以引起更加深度的思考。另一方面，也希望你可以慷慨地解答小伙伴们的问题、分享自己的见解，大家一起加油与进步！