Figure 6-5 Separate Chaining Hash Table
+ +The operations of a hash table implemented with separate chaining have changed as follows: + +- **Querying Elements**: Input `key`, pass through the hash function to obtain the bucket index, access the head node of the list, then traverse the list and compare `key` to find the target key-value pair. +- **Adding Elements**: First access the list head node via the hash function, then add the node (key-value pair) to the list. +- **Deleting Elements**: Access the list head based on the hash function's result, then traverse the list to find and remove the target node. + +Separate chaining has the following limitations: + +- **Increased Space Usage**: The linked list contains node pointers, which consume more memory space than arrays. +- **Reduced Query Efficiency**: Due to the need for linear traversal of the list to find the corresponding element. + +The code below provides a simple implementation of a separate chaining hash table, with two things to note: + +- Lists (dynamic arrays) are used instead of linked lists for simplicity. In this setup, the hash table (array) contains multiple buckets, each of which is a list. +- This implementation includes a method for resizing the hash table. When the load factor exceeds $\frac{2}{3}$, we resize the hash table to twice its original size. + +=== "Python" + + ```python title="hash_map_chaining.py" + class HashMapChaining: + """链式地址哈希表""" + + def __init__(self): + """构造方法""" + self.size = 0 # 键值对数量 + self.capacity = 4 # 哈希表容量 + self.load_thres = 2.0 / 3.0 # 触发扩容的负载因子阈值 + self.extend_ratio = 2 # 扩容倍数 + self.buckets = [[] for _ in range(self.capacity)] # 桶数组 + + def hash_func(self, key: int) -> int: + """哈希函数""" + return key % self.capacity + + def load_factor(self) -> float: + """负载因子""" + return self.size / self.capacity + + def get(self, key: int) -> str | None: + """查询操作""" + index = self.hash_func(key) + bucket = self.buckets[index] + # 遍历桶，若找到 key ，则返回对应 val + for pair in bucket: + if pair.key == key: + return pair.val + # 若未找到 key ，则返回 None + return None + + def put(self, key: int, val: str): + """添加操作""" + # 当负载因子超过阈值时，执行扩容 + if self.load_factor() > self.load_thres: + self.extend() + index = self.hash_func(key) + bucket = self.buckets[index] + # 遍历桶，若遇到指定 key ，则更新对应 val 并返回 + for pair in bucket: + if pair.key == key: + pair.val = val + return + # 若无该 key ，则将键值对添加至尾部 + pair = Pair(key, val) + bucket.append(pair) + self.size += 1 + + def remove(self, key: int): + """删除操作""" + index = self.hash_func(key) + bucket = self.buckets[index] + # 遍历桶，从中删除键值对 + for pair in bucket: + if pair.key == key: + bucket.remove(pair) + self.size -= 1 + break + + def extend(self): + """扩容哈希表""" + # 暂存原哈希表 + buckets = self.buckets + # 初始化扩容后的新哈希表 + self.capacity *= self.extend_ratio + self.buckets = [[] for _ in range(self.capacity)] + self.size = 0 + # 将键值对从原哈希表搬运至新哈希表 + for bucket in buckets: + for pair in bucket: + self.put(pair.key, pair.val) + + def print(self): + """打印哈希表""" + for bucket in self.buckets: + res = [] + for pair in bucket: + res.append(str(pair.key) + " -> " + pair.val) + print(res) + ``` + +=== "C++" + + ```cpp title="hash_map_chaining.cpp" + /* 链式地址哈希表 */ + class HashMapChaining { + private: + int size; // 键值对数量 + int capacity; // 哈希表容量 + double loadThres; // 触发扩容的负载因子阈值 + int extendRatio; // 扩容倍数 + vectorFigure 6-6 Distribution of Key-Value Pairs in Open Addressing (Linear Probing) Hash Table
+ +However, **linear probing tends to create "clustering"**. Specifically, the longer a continuous position in the array is occupied, the more likely these positions are to encounter hash collisions, further promoting the growth of these clusters and eventually leading to deterioration in the efficiency of operations. + +It's important to note that **we cannot directly delete elements in an open addressing hash table**. Deleting an element creates an empty bucket `None` in the array. When searching for elements, if linear probing encounters this empty bucket, it will return, making the elements below this bucket inaccessible. The program may incorrectly assume these elements do not exist, as shown in the Figure 6-7 . + +{ class="animation-figure" } + +Figure 6-7 Query Issues Caused by Deletion in Open Addressing
+ +To solve this problem, we can use a "lazy deletion" mechanism: instead of directly removing elements from the hash table, **use a constant `TOMBSTONE` to mark the bucket**. In this mechanism, both `None` and `TOMBSTONE` represent empty buckets and can hold key-value pairs. However, when linear probing encounters `TOMBSTONE`, it should continue traversing since there may still be key-value pairs below it. + +However, **lazy deletion may accelerate the degradation of hash table performance**. Every deletion operation produces a delete mark, and as `TOMBSTONE` increases, so does the search time, as linear probing may have to skip multiple `TOMBSTONE` to find the target element. + +Therefore, consider recording the index of the first `TOMBSTONE` encountered during linear probing and swapping the target element found with this `TOMBSTONE`. The advantage of this is that each time a query or addition is performed, the element is moved to a bucket closer to the ideal position (starting point of probing), thereby optimizing the query efficiency. + +The code below implements an open addressing (linear probing) hash table with lazy deletion. To make fuller use of the hash table space, we treat the hash table as a "circular array," continuing to traverse from the beginning when the end of the array is passed. + +=== "Python" + + ```python title="hash_map_open_addressing.py" + class HashMapOpenAddressing: + """开放寻址哈希表""" + + def __init__(self): + """构造方法""" + self.size = 0 # 键值对数量 + self.capacity = 4 # 哈希表容量 + self.load_thres = 2.0 / 3.0 # 触发扩容的负载因子阈值 + self.extend_ratio = 2 # 扩容倍数 + self.buckets: list[Pair | None] = [None] * self.capacity # 桶数组 + self.TOMBSTONE = Pair(-1, "-1") # 删除标记 + + def hash_func(self, key: int) -> int: + """哈希函数""" + return key % self.capacity + + def load_factor(self) -> float: + """负载因子""" + return self.size / self.capacity + + def find_bucket(self, key: int) -> int: + """搜索 key 对应的桶索引""" + index = self.hash_func(key) + first_tombstone = -1 + # 线性探测，当遇到空桶时跳出 + while self.buckets[index] is not None: + # 若遇到 key ，返回对应的桶索引 + if self.buckets[index].key == key: + # 若之前遇到了删除标记，则将键值对移动至该索引处 + if first_tombstone != -1: + self.buckets[first_tombstone] = self.buckets[index] + self.buckets[index] = self.TOMBSTONE + return first_tombstone # 返回移动后的桶索引 + return index # 返回桶索引 + # 记录遇到的首个删除标记 + if first_tombstone == -1 and self.buckets[index] is self.TOMBSTONE: + first_tombstone = index + # 计算桶索引，越过尾部则返回头部 + index = (index + 1) % self.capacity + # 若 key 不存在，则返回添加点的索引 + return index if first_tombstone == -1 else first_tombstone + + def get(self, key: int) -> str: + """查询操作""" + # 搜索 key 对应的桶索引 + index = self.find_bucket(key) + # 若找到键值对，则返回对应 val + if self.buckets[index] not in [None, self.TOMBSTONE]: + return self.buckets[index].val + # 若键值对不存在，则返回 None + return None + + def put(self, key: int, val: str): + """添加操作""" + # 当负载因子超过阈值时，执行扩容 + if self.load_factor() > self.load_thres: + self.extend() + # 搜索 key 对应的桶索引 + index = self.find_bucket(key) + # 若找到键值对，则覆盖 val 并返回 + if self.buckets[index] not in [None, self.TOMBSTONE]: + self.buckets[index].val = val + return + # 若键值对不存在，则添加该键值对 + self.buckets[index] = Pair(key, val) + self.size += 1 + + def remove(self, key: int): + """删除操作""" + # 搜索 key 对应的桶索引 + index = self.find_bucket(key) + # 若找到键值对，则用删除标记覆盖它 + if self.buckets[index] not in [None, self.TOMBSTONE]: + self.buckets[index] = self.TOMBSTONE + self.size -= 1 + + def extend(self): + """扩容哈希表""" + # 暂存原哈希表 + buckets_tmp = self.buckets + # 初始化扩容后的新哈希表 + self.capacity *= self.extend_ratio + self.buckets = [None] * self.capacity + self.size = 0 + # 将键值对从原哈希表搬运至新哈希表 + for pair in buckets_tmp: + if pair not in [None, self.TOMBSTONE]: + self.put(pair.key, pair.val) + + def print(self): + """打印哈希表""" + for pair in self.buckets: + if pair is None: + print("None") + elif pair is self.TOMBSTONE: + print("TOMBSTONE") + else: + print(pair.key, "->", pair.val) + ``` + +=== "C++" + + ```cpp title="hash_map_open_addressing.cpp" + /* 开放寻址哈希表 */ + class HashMapOpenAddressing { + private: + int size; // 键值对数量 + int capacity = 4; // 哈希表容量 + const double loadThres = 2.0 / 3.0; // 触发扩容的负载因子阈值 + const int extendRatio = 2; // 扩容倍数 + vectorFigure 6-1 Abstract representation of a hash table
+ +Apart from hash tables, arrays and linked lists can also be used to implement querying functions. Their efficiency is compared in the Table 6-1 . + +- **Adding Elements**: Simply add the element to the end of the array (or linked list), using $O(1)$ time. +- **Querying Elements**: Since the array (or linked list) is unordered, it requires traversing all the elements, using $O(n)$ time. +- **Deleting Elements**: First, locate the element, then delete it from the array (or linked list), using $O(n)$ time. + +Table 6-1 Comparison of Element Query Efficiency
+ +
+
+| | Array | Linked List | Hash Table |
+| -------------- | ------ | ----------- | ---------- |
+| Find Element | $O(n)$ | $O(n)$ | $O(1)$ |
+| Add Element | $O(1)$ | $O(1)$ | $O(1)$ |
+| Delete Element | $O(n)$ | $O(n)$ | $O(1)$ |
+
+
+
+Observations reveal that **the time complexity for adding, deleting, and querying in a hash table is $O(1)$**, which is highly efficient.
+
+## 6.1.1 Common Operations of Hash Table
+
+Common operations of a hash table include initialization, querying, adding key-value pairs, and deleting key-value pairs, etc. Example code is as follows:
+
+=== "Python"
+
+ ```python title="hash_map.py"
+ # Initialize hash table
+ hmap: dict = {}
+
+ # Add operation
+ # Add key-value pair (key, value) to the hash table
+ hmap[12836] = "Xiao Ha"
+ hmap[15937] = "Xiao Luo"
+ hmap[16750] = "Xiao Suan"
+ hmap[13276] = "Xiao Fa"
+ hmap[10583] = "Xiao Ya"
+
+ # Query operation
+ # Input key into hash table, get value
+ name: str = hmap[15937]
+
+ # Delete operation
+ # Delete key-value pair (key, value) from hash table
+ hmap.pop(10583)
+ ```
+
+=== "C++"
+
+ ```cpp title="hash_map.cpp"
+ /* Initialize hash table */
+ unordered_mapFigure 6-2 Working principle of hash function
+ +The following code implements a simple hash table. Here, we encapsulate `key` and `value` into a class `Pair` to represent the key-value pair. + +=== "Python" + + ```python title="array_hash_map.py" + class Pair: + """键值对""" + + def __init__(self, key: int, val: str): + self.key = key + self.val = val + + class ArrayHashMap: + """基于数组实现的哈希表""" + + def __init__(self): + """构造方法""" + # 初始化数组，包含 100 个桶 + self.buckets: list[Pair | None] = [None] * 100 + + def hash_func(self, key: int) -> int: + """哈希函数""" + index = key % 100 + return index + + def get(self, key: int) -> str: + """查询操作""" + index: int = self.hash_func(key) + pair: Pair = self.buckets[index] + if pair is None: + return None + return pair.val + + def put(self, key: int, val: str): + """添加操作""" + pair = Pair(key, val) + index: int = self.hash_func(key) + self.buckets[index] = pair + + def remove(self, key: int): + """删除操作""" + index: int = self.hash_func(key) + # 置为 None ，代表删除 + self.buckets[index] = None + + def entry_set(self) -> list[Pair]: + """获取所有键值对""" + result: list[Pair] = [] + for pair in self.buckets: + if pair is not None: + result.append(pair) + return result + + def key_set(self) -> list[int]: + """获取所有键""" + result = [] + for pair in self.buckets: + if pair is not None: + result.append(pair.key) + return result + + def value_set(self) -> list[str]: + """获取所有值""" + result = [] + for pair in self.buckets: + if pair is not None: + result.append(pair.val) + return result + + def print(self): + """打印哈希表""" + for pair in self.buckets: + if pair is not None: + print(pair.key, "->", pair.val) + ``` + +=== "C++" + + ```cpp title="array_hash_map.cpp" + /* 键值对 */ + struct Pair { + public: + int key; + string val; + Pair(int key, string val) { + this->key = key; + this->val = val; + } + }; + + /* 基于数组实现的哈希表 */ + class ArrayHashMap { + private: + vectorFigure 6-3 Example of hash collision
+ +It is easy to understand that the larger the capacity $n$ of the hash table, the lower the probability of multiple keys being allocated to the same bucket, and the fewer the collisions. Therefore, **expanding the capacity of the hash table can reduce hash collisions**. + +As shown in the Figure 6-4 , before expansion, key-value pairs `(136, A)` and `(236, D)` collided; after expansion, the collision is resolved. + +{ class="animation-figure" } + +Figure 6-4 Hash table expansion
+ +Similar to array expansion, resizing a hash table requires migrating all key-value pairs from the original hash table to the new one, which is time-consuming. Furthermore, since the capacity `capacity` of the hash table changes, we need to recalculate the storage positions of all key-value pairs using the hash function, which adds to the computational overhead of the resizing process. Therefore, programming languages often reserve a sufficiently large capacity for the hash table to prevent frequent resizing. + +The "load factor" is an important concept for hash tables. It is defined as the ratio of the number of elements in the hash table to the number of buckets. It is used to measure the severity of hash collisions and **is often used as a trigger for resizing the hash table**. For example, in Java, when the load factor exceeds $0.75$, the system will resize the hash table to twice its original size. diff --git a/docs-en/chapter_hashing/index.md b/docs-en/chapter_hashing/index.md new file mode 100644 index 000000000..5daf4c5ba --- /dev/null +++ b/docs-en/chapter_hashing/index.md @@ -0,0 +1,25 @@ +--- +comments: true +icon: material/table-search +--- + +# Chapter 6. Hash Table + +
+
+{ class="cover-image" }
+
+
+
+!!! abstract
+
+ In the world of computing, a hash table is like a wise librarian.
+
+ He knows how to calculate index numbers, allowing it to quickly locate the target book.
+
+## Chapter Contents
+
+- [6.1 Hash Table](https://www.hello-algo.com/en/chapter_hashing/hash_map/)
+- [6.2 Hash Collision](https://www.hello-algo.com/en/chapter_hashing/hash_collision/)
+- [6.3 Hash Algorithm](https://www.hello-algo.com/en/chapter_hashing/hash_algorithm/)
+- [6.4 Summary](https://www.hello-algo.com/en/chapter_hashing/summary/)
diff --git a/docs-en/chapter_hashing/summary.md b/docs-en/chapter_hashing/summary.md
new file mode 100644
index 000000000..ec68c7859
--- /dev/null
+++ b/docs-en/chapter_hashing/summary.md
@@ -0,0 +1,51 @@
+---
+comments: true
+---
+
+# 6.4 Summary
+
+### 1. Key Review
+
+- Given an input `key`, a hash table can retrieve the corresponding `value` in $O(1)$ time, which is highly efficient.
+- Common hash table operations include querying, adding key-value pairs, deleting key-value pairs, and traversing the hash table.
+- The hash function maps a `key` to an array index, allowing access to the corresponding bucket to retrieve the `value`.
+- Two different keys may end up with the same array index after hashing, leading to erroneous query results. This phenomenon is known as hash collision.
+- The larger the capacity of the hash table, the lower the probability of hash collisions. Therefore, hash table resizing can mitigate hash collisions. Similar to array resizing, hash table resizing is costly.
+- Load factor, defined as the ratio of the number of elements to the number of buckets in the hash table, reflects the severity of hash collisions and is often used as a trigger for resizing the hash table.
+- Chaining addresses hash collisions by converting each element into a linked list, storing all colliding elements in the same list. However, excessively long lists can reduce query efficiency, which can be improved by converting the lists into red-black trees.
+- Open addressing handles hash collisions through multiple probes. Linear probing uses a fixed step size but cannot delete elements and is prone to clustering. Multiple hashing uses several hash functions for probing, making it less susceptible to clustering but increasing computational load.
+- Different programming languages adopt various hash table implementations. For example, Java's `HashMap` uses chaining, while Python's `dict` employs open addressing.
+- In hash tables, we desire hash algorithms with determinism, high efficiency, and uniform distribution. In cryptography, hash algorithms should also possess collision resistance and the avalanche effect.
+- Hash algorithms typically use large prime numbers as moduli to ensure uniform distribution of hash values and reduce hash collisions.
+- Common hash algorithms include MD5, SHA-1, SHA-2, and SHA-3. MD5 is often used for file integrity checks, while SHA-2 is commonly used in secure applications and protocols.
+- Programming languages usually provide built-in hash algorithms for data types to calculate bucket indices in hash tables. Generally, only immutable objects are hashable.
+
+### 2. Q & A
+
+**Q**: When does the time complexity of a hash table degrade to $O(n)$?
+
+The time complexity of a hash table can degrade to $O(n)$ when hash collisions are severe. When the hash function is well-designed, the capacity is set appropriately, and collisions are evenly distributed, the time complexity is $O(1)$. We usually consider the time complexity to be $O(1)$ when using built-in hash tables in programming languages.
+
+**Q**: Why not use the hash function $f(x) = x$? This would eliminate collisions.
+
+Under the hash function $f(x) = x$, each element corresponds to a unique bucket index, which is equivalent to an array. However, the input space is usually much larger than the output space (array length), so the last step of a hash function is often to take the modulo of the array length. In other words, the goal of a hash table is to map a larger state space to a smaller one while providing $O(1)$ query efficiency.
+
+**Q**: Why can hash tables be more efficient than arrays, linked lists, or binary trees, even though they are implemented using these structures?
+
+Firstly, hash tables have higher time efficiency but lower space efficiency. A significant portion of memory in hash tables remains unused.
+
+Secondly, they are only more efficient in specific use cases. If a feature can be implemented with the same time complexity using an array or a linked list, it's usually faster than using a hash table. This is because the computation of the hash function incurs overhead, making the constant factor in the time complexity larger.
+
+Lastly, the time complexity of hash tables can degrade. For example, in chaining, we perform search operations in a linked list or red-black tree, which still risks degrading to $O(n)$ time.
+
+**Q**: Does multiple hashing also have the flaw of not being able to delete elements directly? Can space marked as deleted be reused?
+
+Multiple hashing is a form of open addressing, and all open addressing methods have the drawback of not being able to delete elements directly; they require marking elements as deleted. Marked spaces can be reused. When inserting new elements into the hash table, and the hash function points to a position marked as deleted, that position can be used by the new element. This maintains the probing sequence of the hash table while ensuring efficient use of space.
+
+**Q**: Why do hash collisions occur during the search process in linear probing?
+
+During the search process, the hash function points to the corresponding bucket and key-value pair. If the `key` doesn't match, it indicates a hash collision. Therefore, linear probing will search downwards at a predetermined step size until the correct key-value pair is found or the search fails.
+
+**Q**: Why can resizing a hash table alleviate hash collisions?
+
+The last step of a hash function often involves taking the modulo of the array length $n$, to keep the output within the array index range. When resizing, the array length $n$ changes, and the indices corresponding to the keys may also change. Keys that were previously mapped to the same bucket might be distributed across multiple buckets after resizing, thereby mitigating hash collisions.
diff --git a/docs-en/chapter_stack_and_queue/deque.md b/docs-en/chapter_stack_and_queue/deque.md
index 5b08cbff7..3129f7f17 100644
--- a/docs-en/chapter_stack_and_queue/deque.md
+++ b/docs-en/chapter_stack_and_queue/deque.md
@@ -340,7 +340,7 @@ Similarly, we can directly use the double-ended queue classes implemented in pro
```
-??? pythontutor "Visualizing Code"
+??? pythontutor "Code Visualization"
diff --git a/docs-en/chapter_stack_and_queue/index.md b/docs-en/chapter_stack_and_queue/index.md
index 04c2f508b..9668fdaa2 100644
--- a/docs-en/chapter_stack_and_queue/index.md
+++ b/docs-en/chapter_stack_and_queue/index.md
@@ -13,9 +13,9 @@ icon: material/stack-overflow
!!! abstract
- Stacks are like stacking cats, while queues are like cats lining up.
+ A stack is like cats placed on top of each other, while a queue is like cats lined up one by one.
- They respectively represent the logical relationships of Last-In-First-Out (LIFO) and First-In-First-Out (FIFO).
+ They represent the logical relationships of Last-In-First-Out (LIFO) and First-In-First-Out (FIFO), respectively.
## Chapter Contents
diff --git a/docs-en/chapter_stack_and_queue/queue.md b/docs-en/chapter_stack_and_queue/queue.md
index 6d1e0f3c7..514908285 100755
--- a/docs-en/chapter_stack_and_queue/queue.md
+++ b/docs-en/chapter_stack_and_queue/queue.md
@@ -318,7 +318,7 @@ We can directly use the ready-made queue classes in programming languages:
```
-??? pythontutor "Visualizing Code"
+??? pythontutor "Code Visualization"
@@ -1212,7 +1212,7 @@ Below is the code for implementing a queue using a linked list:
}
```
-??? pythontutor "Visualizing Code"
+??? pythontutor "Code Visualization"
@@ -2128,7 +2128,7 @@ For a circular array, `front` or `rear` needs to loop back to the start of the a
}
```
-??? pythontutor "Visualizing Code"
+??? pythontutor "Code Visualization"
diff --git a/docs-en/chapter_stack_and_queue/stack.md b/docs-en/chapter_stack_and_queue/stack.md
index 45ee29c7a..d8498903f 100755
--- a/docs-en/chapter_stack_and_queue/stack.md
+++ b/docs-en/chapter_stack_and_queue/stack.md
@@ -312,7 +312,7 @@ Typically, we can directly use the stack class built into the programming langua
```
-??? pythontutor "Visualizing Code"
+??? pythontutor "Code Visualization"
@@ -1084,7 +1084,7 @@ Below is an example code for implementing a stack based on a linked list:
}
```
-??? pythontutor "Visualizing Code"
+??? pythontutor "Code Visualization"
@@ -1695,7 +1695,7 @@ Since the elements to be pushed onto the stack may continuously increase, we can
}
```
-??? pythontutor "Visualizing Code"
+??? pythontutor "Code Visualization"
diff --git a/docs/chapter_hashing/hash_algorithm.md b/docs/chapter_hashing/hash_algorithm.md
index 8ed1a7fcb..a7b901cb2 100644
--- a/docs/chapter_hashing/hash_algorithm.md
+++ b/docs/chapter_hashing/hash_algorithm.md
@@ -841,7 +841,6 @@ $$
let mut dec_hasher = DefaultHasher::new();
dec.to_bits().hash(&mut dec_hasher);
let hash_dec = dec_hasher.finish();
- println!("小数 {} 的哈希值为 {}", dec, hash_dec);
// 小数 3.14159 的哈希值为 2566941990314602357
let str = "Hello 算法";
diff --git a/docs/chapter_sorting/selection_sort.md b/docs/chapter_sorting/selection_sort.md
index 7fafc6e6c..343f0fc54 100644
--- a/docs/chapter_sorting/selection_sort.md
+++ b/docs/chapter_sorting/selection_sort.md
@@ -241,6 +241,9 @@ comments: true
```rust title="selection_sort.rs"
/* 选择排序 */
fn selection_sort(nums: &mut [i32]) {
+ if nums.is_empty() {
+ return;
+ }
let n = nums.len();
// 外循环：未排序区间为 [i, n-1]
for i in 0..n-1 {
diff --git a/docs/index.md b/docs/index.md
index 73e2818e3..831b3b287 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -93,14 +93,14 @@ hide:
-