Update the chapter of hashing.

codes/java/chapter_hashing/array_hash_map.java

@@ -22,15 +22,15 @@ class ArrayHashMap {
     private List<Entry> bucket;
     public ArrayHashMap() {
         // 初始化一个长度为 10 的桶（数组）
-        bucket = new ArrayList<>(10);
+        bucket = new ArrayList<>();
-        for (int i = 0; i < 10; i++) {
+        for (int i = 0; i < 100; i++) {
             bucket.add(null);
         }
     }
 
     /* 哈希函数 */
     private int hashFunc(int key) {
-        int index = key % 10000;
+        int index = key % 100;
         return index;
     }
 
@@ -102,23 +102,23 @@ public class array_hash_map {
 
         /* 添加操作 */
         // 在哈希表中添加键值对 (key, value)
-        map.put(10001, "小哈");   
+        map.put(12836, "小哈");   
-        map.put(10002, "小啰");   
+        map.put(15937, "小啰");   
-        map.put(10003, "小算");   
+        map.put(16750, "小算");   
-        map.put(10004, "小法");
+        map.put(13276, "小法");
-        map.put(10005, "小哇");
+        map.put(10583, "小鸭");
         System.out.println("\n添加完成后，哈希表为\nKey -> Value");
         map.print();
 
         /* 查询操作 */
         // 向哈希表输入键 key ，得到值 value
-        String name = map.get(10002);
+        String name = map.get(15937);
-        System.out.println("\n输入学号 10002 ，查询到姓名 " + name);
+        System.out.println("\n输入学号 15937 ，查询到姓名 " + name);
 
         /* 删除操作 */
         // 在哈希表中删除键值对 (key, value)
-        map.remove(10005);
+        map.remove(10583);
-        System.out.println("\n删除 10005 后，哈希表为\nKey -> Value");
+        System.out.println("\n删除 10583 后，哈希表为\nKey -> Value");
         map.print();
 
         /* 遍历哈希表 */

codes/java/chapter_hashing/hash_map.java

@@ -15,23 +15,23 @@ public class hash_map {
 
         /* 添加操作 */
         // 在哈希表中添加键值对 (key, value)
-        map.put(10001, "小哈");   
+        map.put(12836, "小哈");   
-        map.put(10002, "小啰");   
+        map.put(15937, "小啰");   
-        map.put(10003, "小算");   
+        map.put(16750, "小算");   
-        map.put(10004, "小法");
+        map.put(13276, "小法");
-        map.put(10005, "小哇");
+        map.put(10583, "小鸭");
         System.out.println("\n添加完成后，哈希表为\nKey -> Value");
         PrintUtil.printHashMap(map);
 
         /* 查询操作 */
         // 向哈希表输入键 key ，得到值 value
-        String name = map.get(10002);
+        String name = map.get(15937);
-        System.out.println("\n输入学号 10002 ，查询到姓名 " + name);
+        System.out.println("\n输入学号 15937 ，查询到姓名 " + name);
 
         /* 删除操作 */
         // 在哈希表中删除键值对 (key, value)
-        map.remove(10005);
+        map.remove(10583);
-        System.out.println("\n删除 10005 后，哈希表为\nKey -> Value");
+        System.out.println("\n删除 10583 后，哈希表为\nKey -> Value");
         PrintUtil.printHashMap(map);
 
         /* 遍历哈希表 */

codes/python/chapter_stack_and_queue/queue.py

@@ -1,5 +1,5 @@
 '''
-File: que.py
+File: queue.py
 Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
 '''

docs/chapter_hashing/hash_map.md

@@ -4,9 +4,34 @@ comments: true
 
 # 哈希表
 
-哈希表通过建立「键 Key」和「值 Value」之间的映射，实现高效的元素查找。具体地，查询操作（给定一个 Key 查询得到 Value）的时间复杂度为 $O(1)$ 。
+哈希表通过建立「键 Key」和「值 Value」之间的映射，实现高效的元素查找。具体地，输入一个 Key ，在哈希表中查询并获取 Value ，时间复杂度为 $O(1)$ 。
 
-（图）
+例如，给定一个包含 $n$ 个学生的数据库，每个学生有 "姓名 `name` ” 和 “学号 `id` ” 两项数据，希望实现一个查询功能：**输入一个学号，返回对应的姓名**，则可以使用哈希表实现。
+
+![hash_map](hash_map.assets/hash_map.png)
+
+<p align="center"> Fig. 哈希表抽象表示 </p>
+
+## 哈希表优势
+
+除了哈希表之外，还可以使用以下数据结构来实现上述查询功能：
+
+- **无序数组：** 每个元素为  `[学号, 姓名]` ；
+- **有序数组：** 将 `1.` 中的数组按照学号从小到大排序；
+- **链表：** 每个结点的值为 `[学号, 姓名]` ；
+- **二叉搜索树：** 每个结点的值为 `[学号, 姓名]` ，根据学号大小来构建树；
+
+使用上述方法，各项操作的时间复杂度如下表所示（在此不做赘述，详解可见 [二叉搜索树章节](https://www.hello-algo.com/chapter_tree/binary_search_tree/#_6)）。无论是查找元素、还是增删元素，哈希表的时间复杂度都是 $O(1)$ ，全面胜出！
+
+<div class="center-table" markdown>
+
+|          | 无序数组 | 有序数组    | 链表   | 二叉搜索树  | 哈希表 |
+| -------- | -------- | ----------- | ------ | ----------- | ------ |
+| 查找元素 | $O(n)$   | $O(\log n)$ | $O(n)$ | $O(\log n)$ | $O(1)$ |
+| 插入元素 | $O(1)$   | $O(n)$      | $O(1)$ | $O(\log n)$ | $O(1)$ |
+| 删除元素 | $O(n)$   | $O(n)$      | $O(n)$ | $O(\log n)$ | $O(1)$ |
+
+</div>
 
 ## 哈希表常用操作
 
@@ -18,19 +43,19 @@ Map<Integer, String> map = new HashMap<>();
 
 /* 添加操作 */
 // 在哈希表中添加键值对 (key, value)
-map.put(10001, "小哈");   
+map.put(12836, "小哈");   
-map.put(10002, "小啰");   
+map.put(15937, "小啰");   
-map.put(10003, "小算");   
+map.put(16750, "小算");   
-map.put(10004, "小法");
+map.put(13276, "小法");
-map.put(10005, "小哇");
+map.put(10583, "小鸭");
 
 /* 查询操作 */
 // 向哈希表输入键 key ，得到值 value
-String name = map.get(10002);
+String name = map.get(15937);
 
 /* 删除操作 */
 // 在哈希表中删除键值对 (key, value)
-map.remove(10005);
+map.remove(10583);
 ```
 
 遍历哈希表有三种方式，即 **遍历键值对、遍历键、遍历值**。
@@ -51,28 +76,6 @@ for (String val: map.values()) {
 }
 ```
 
-## 哈希表优势
-
-给定一个包含 $n$ 个学生的数据库，每个学生有 "姓名 `name` ” 和 “学号 `id` ” 两项数据，希望实现一个查询功能，即 **输入一个学号，返回对应的姓名**，那么可以使用哪些数据结构来存储呢？
-
-- **无序数组：** 每个元素为  `[学号, 姓名]` ；
-- **有序数组：** 将 `1.` 中的数组按照学号从小到大排序；
-- **链表：** 每个结点的值为 `[学号, 姓名]` ；
-- **二叉搜索树：** 每个结点的值为 `[学号, 姓名]` ，根据学号大小来构建树；
-- **哈希表：** 以学号为 Key 、姓名为 Value 。
-
-使用上述方法，各项操作的时间复杂度如下表所示（在此不做赘述，详解可见 [二叉搜索树章节](https://www.hello-algo.com/chapter_tree/binary_search_tree/#_6)），**哈希表全面胜出！**
-
-<div class="center-table" markdown>
-
-|              | 无序数组 | 有序数组    | 链表   | 二叉搜索树  | 哈希表 |
-| ------------ | -------- | ----------- | ------ | ----------- | ------ |
-| 查找指定元素 | $O(n)$   | $O(\log n)$ | $O(n)$ | $O(\log n)$ | $O(1)$ |
-| 插入元素     | $O(1)$   | $O(n)$      | $O(1)$ | $O(\log n)$ | $O(1)$ |
-| 删除元素     | $O(n)$   | $O(n)$      | $O(n)$ | $O(\log n)$ | $O(1)$ |
-
-</div>
-
 ## 哈希函数
 
 哈希表中存储元素的数据结构被称为「桶 Bucket」，底层实现可能是数组、链表、二叉树（红黑树），或是它们的组合。
@@ -87,10 +90,12 @@ for (String val: map.values()) {
 以上述学生数据 `Key 学号 -> Value 姓名` 为例，我们可以将「哈希函数」设计为 
 
 $$
-f(x) = x \% 10000
+f(x) = x \% 100
 $$
 
-（图）
+![hash_function](hash_map.assets/hash_function.png)
+
+<p align="center"> Fig. 哈希函数 </p>
 
 ```java title="array_hash_map.java"
 /* 键值对 int->String */
@@ -107,16 +112,16 @@ class Entry {
 class ArrayHashMap {
     private List<Entry> bucket;
     public ArrayHashMap() {
-        // 初始化一个长度为 10 的桶（数组）
+        // 初始化一个长度为 100 的桶（数组）
         bucket = new ArrayList<>();
-        for (int i = 0; i < 10; i++) {
+        for (int i = 0; i < 100; i++) {
             bucket.add(null);
         }
     }
 
     /* 哈希函数 */
     private int hashFunc(int key) {
-        int index = key % 10000;
+        int index = key % 100;
         return index;
     }
 
@@ -146,8 +151,18 @@ class ArrayHashMap {
 
 ## 哈希冲突
 
-细心的同学可能会发现，哈希函数 $f(x) = x \% 10000$ 会在某些情况下失效。例如，当输入的 Key 为 10001, 20001, 30001, ... 时，哈希函数的计算结果都是 1 ，指向同一个 Value ，表明不同学号指向了同一个人，这明显是不对的。
+细心的同学可能会发现，**哈希函数 $f(x) = x \% 100$ 会在某些情况下失效**。具体地，当输入的 Key 后两位相同时，哈希函数的计算结果也相同，指向同一个 Value 。例如，分别查询两个学号 12836 和 20336 ，则有
+$$
+f(12836) = f(20336) = 36
+$$
+导致两个学号指向了同一个姓名，这明显是不对的。我们将这种现象称为「哈希冲突 Hash Collision」，其会严重影响查询的正确性，我们将如何避免哈希冲突的问题留在下章讨论。
+
+![hash_collision](hash_map.assets/hash_collision.png)
+
+<p align="center"> Fig. 哈希冲突 </p>
 
-上述现象被称为「哈希冲突 Hash Collision」，其会严重影响查询的正确性，我们将如何避免哈希冲突的问题留在下章讨论。
+综上所述，一个优秀的「哈希函数」应该具备以下特性：
 
-（图）
+- 尽量少地发生哈希冲突；
+- 时间复杂度 $O(1)$ ，计算尽可能高效；
+- 空间使用率高，即 “键值对占用空间 / 哈希表总占用空间” 尽可能大；