build

en/docs/chapter_hashing/hash_algorithm.md

@@ -12,7 +12,7 @@ If hash collisions occur too frequently, the performance of the hash table will
 
 <p align="center"> Figure 6-8 &nbsp; Ideal and worst cases of hash collisions </p>
 
-**The distribution of key-value pairs is determined by the hash function**. Recalling the calculation steps of the hash function, first compute the hash value, then take the modulo by the array length:
+**The distribution of key-value pairs is determined by the hash function**. Recall the steps of the hash function: first compute the hash value, then take it modulo the array length:
 
 ```shell
 index = hash(key) % capacity
@@ -24,7 +24,7 @@ This means that, to reduce the probability of hash collisions, we should focus o
 
 ## 6.3.1 &nbsp; Goals of Hash Algorithms
 
-To achieve a "fast and stable" hash table data structure, hash algorithms should have the following characteristics:
+To build a hash table that is both fast and robust, a hash algorithm should have the following properties:
 
 - **Determinism**: For the same input, the hash algorithm should always produce the same output. Only then can the hash table be reliable.
 - **High efficiency**: The process of computing the hash value should be fast enough. The smaller the computational overhead, the more practical the hash table.
@@ -35,7 +35,7 @@ In fact, hash algorithms are not only used to implement hash tables but are also
 - **Password storage**: To protect the security of user passwords, systems usually do not store the plaintext passwords but rather the hash values of the passwords. When a user enters a password, the system calculates the hash value of the input and compares it with the stored hash value. If they match, the password is considered correct.
 - **Data integrity check**: The data sender can calculate the hash value of the data and send it along; the receiver can recalculate the hash value of the received data and compare it with the received hash value. If they match, the data is considered intact.
 
-For cryptographic applications, to prevent reverse engineering such as deducing the original password from the hash value, hash algorithms need higher-level security features.
+For cryptographic applications, hash algorithms need stronger security properties to prevent reverse engineering, such as inferring the original password from a hash value.
 
 - **Unidirectionality**: It should be impossible to deduce any information about the input data from the hash value.
 - **Collision resistance**: It should be extremely difficult to find two different inputs that produce the same hash value.
@@ -48,7 +48,7 @@ Note that **"uniform distribution" and "collision resistance" are two independen
 The design of hash algorithms is a complex issue that requires consideration of many factors. However, for some less demanding scenarios, we can also design some simple hash algorithms.
 
 - **Additive hash**: Add up the ASCII codes of each character in the input and use the total sum as the hash value.
-- **Multiplicative hash**: Utilize the non-correlation of multiplication, multiplying each round by a constant, accumulating the ASCII codes of each character into the hash value.
+- **Multiplicative hash**: Leverage the low correlation introduced by multiplication: multiply by a constant at each step and accumulate the ASCII codes of the characters into the hash value.
 - **XOR hash**: Accumulate the hash value by XORing each element of the input data.
 - **Rotating hash**: Accumulate the ASCII code of each character into a hash value, performing a rotation operation on the hash value before each accumulation.
 
@@ -642,9 +642,9 @@ The design of hash algorithms is a complex issue that requires consideration of
     end
     ```
 
-It is observed that the last step of each hash algorithm is to take the modulus of the large prime number $1000000007$ to ensure that the hash value is within an appropriate range. It is worth pondering why emphasis is placed on modulo a prime number, or what are the disadvantages of modulo a composite number? This is an interesting question.
+We can observe that the final step of each hash algorithm is to take the result modulo the large prime $1000000007$, ensuring that the hash value stays within a suitable range. This naturally raises a question: why emphasize using a prime modulus, and what are the drawbacks of using a composite modulus?
 
-To conclude: **Using a large prime number as the modulus can maximize the uniform distribution of hash values**. Since a prime number does not share common factors with other numbers, it can reduce the periodic patterns caused by the modulo operation, thus avoiding hash collisions.
+In short: **using a large prime as the modulus helps maximize the uniformity of hash values**. Because a prime shares no common factors with other numbers, it can reduce periodic patterns introduced by the modulo operation and thus mitigate hash collisions.
 
 For example, suppose we choose the composite number $9$ as the modulus, which can be divided by $3$, then all `key` divisible by $3$ will be mapped to hash values $0$, $3$, $6$.
 
@@ -656,7 +656,7 @@ $$
 \end{aligned}
 $$
 
-If the input `key` happens to have this kind of arithmetic sequence distribution, then the hash values will cluster, thereby exacerbating hash collisions. Now, suppose we replace `modulus` with the prime number $13$, since there are no common factors between `key` and `modulus`, the uniformity of the output hash values will be significantly improved.
+If the input `key` values happen to follow this kind of arithmetic progression, the hash values will cluster, worsening hash collisions. Now suppose we replace `modulus` with the prime number $13$. Because `key` and `modulus` share no common factors, the output hash values become much more evenly distributed.
 
 $$
 \begin{aligned}
@@ -672,7 +672,7 @@ In summary, we usually choose a prime number as the modulus, and this prime numb
 
 ## 6.3.3 &nbsp; Common Hash Algorithms
 
-It is not hard to see that the simple hash algorithms mentioned above are quite "fragile" and far from reaching the design goals of hash algorithms. For example, since addition and XOR obey the commutative law, additive hash and XOR hash cannot distinguish strings with the same content but in different order, which may exacerbate hash collisions and cause security issues.
+It is easy to see that the simple hash algorithms introduced above are fairly "fragile" and fall far short of the design goals of hash algorithms. For example, because addition and XOR are commutative, additive hash and XOR hash cannot distinguish strings with the same characters in a different order, which may worsen hash collisions and introduce security risks.
 
 In practice, we usually use some standard hash algorithms, such as MD5, SHA-1, SHA-2, and SHA-3. They can map input data of any length to a fixed-length hash value.
 
@@ -696,14 +696,14 @@ Over the past century, hash algorithms have been in a continuous process of upgr
 
 </div>
 
-# Hash Values in Data Structures
+## 6.3.4 &nbsp; Hash Values in Data Structures
 
-We know that the keys in a hash table can be of various data types such as integers, decimals, or strings. Programming languages usually provide built-in hash algorithms for these data types to calculate the bucket indices in the hash table. Taking Python as an example, we can use the `hash()` function to compute the hash values for various data types.
+We know that hash table keys can be integers, floating-point numbers, strings, and other data types. Programming languages usually provide built-in hash algorithms for these types to compute bucket indices in a hash table. Taking Python as an example, we can call the `hash()` function to compute hash values for various data types.
 
 - The hash values of integers and booleans are their own values.
 - The calculation of hash values for floating-point numbers and strings is more complex, and interested readers are encouraged to study this on their own.
-- The hash value of a tuple is a combination of the hash values of each of its elements, resulting in a single hash value.
-- The hash value of an object is generated based on its memory address. By overriding the hash method of an object, hash values can be generated based on content.
+- The hash value of a tuple is obtained by hashing each of its elements and combining those results into a single hash value.
+- An object's hash value is typically generated from its memory address. By overriding the object's hash method, it can instead be generated from the object's contents.
 
 !!! tip
 

en/docs/chapter_hashing/hash_collision.md

@@ -11,21 +11,21 @@ Hash collisions can lead to incorrect query results, severely impacting the usab
 1. Improve the hash table data structure so that **the hash table can function normally when hash collisions occur**.
 2. Only expand when necessary, that is, only when hash collisions are severe.
 
-The main methods for improving the structure of hash tables include "separate chaining" and "open addressing".
+The main approaches to improving a hash table's structure are separate chaining and open addressing.
 
 ## 6.2.1   Separate Chaining
 
-In the original hash table, each bucket can store only one key-value pair. <u>Separate chaining</u> converts a single element into a linked list, treating key-value pairs as linked list nodes and storing all colliding key-value pairs in the same linked list. Figure 6-5 shows an example of a separate chaining hash table.
+In the original hash table, each bucket can store only one key-value pair. <u>Separate chaining</u> replaces the single element in each bucket with a linked list, treating each key-value pair as a node and storing all colliding key-value pairs in the same list. Figure 6-5 shows an example of a separate chaining hash table.
 
 ![Separate chaining hash table](hash_collision.assets/hash_table_chaining.png){ class="animation-figure" }
 
 <p align="center"> Figure 6-5 &nbsp; Separate chaining hash table </p>
 
-The operations of a hash table implemented with separate chaining have changed as follows:
+In a hash table implemented with separate chaining, the basic operations work as follows:
 
-- **Querying elements**: Input `key`, obtain the bucket index through the hash function, then access the head node of the linked list, then traverse the linked list and compare `key` to find the target key-value pair.
-- **Adding elements**: First access the linked list head node through the hash function, then append the node (key-value pair) to the linked list.
-- **Deleting elements**: Access the head of the linked list based on the result of the hash function, then traverse the linked list to find the target node and delete it.
+- **Querying elements**: Input `key`, compute the bucket index using the hash function, access the head of the corresponding linked list, and traverse the list while comparing keys until the target key-value pair is found.
+- **Adding elements**: First use the hash function to locate the corresponding linked list, then insert the node (key-value pair) into the list.
+- **Deleting elements**: Use the hash function to locate the corresponding linked list, then traverse it to find and delete the target node.
 
 Separate chaining has the following limitations:
 
@@ -1517,40 +1517,40 @@ The code below provides a simple implementation of a separate chaining hash tabl
     end
     ```
 
-It's worth noting that when the linked list is very long, the query efficiency $O(n)$ is poor. **In this case, the list can be converted to an "AVL tree" or "Red-Black tree"** to optimize the time complexity of the query operation to $O(\log n)$.
+It's worth noting that when the linked list becomes very long, the query time $O(n)$ is poor. **In this case, the linked list can be converted into an AVL tree or a red-black tree**, reducing the time complexity of lookups to $O(\log n)$.
 
 ## 6.2.2 &nbsp; Open Addressing
 
-<u>Open addressing</u> does not introduce additional data structures but instead handles hash collisions through "multiple probes". The probing methods mainly include linear probing, quadratic probing, and double hashing.
+<u>Open addressing</u> does not introduce additional data structures. Instead, it handles hash collisions through repeated probing. Common probing strategies include linear probing, quadratic probing, and multiple hashing.
 
 Let's use linear probing as an example to introduce the mechanism of open addressing hash tables.
 
 ### 1. &nbsp; Linear Probing
 
-Linear probing uses a fixed-step linear search for probing, and its operation method differs from ordinary hash tables.
+Linear probing uses a fixed step size to probe sequentially, so its operations differ somewhat from those of an ordinary hash table.
 
-- **Inserting elements**: Calculate the bucket index using the hash function. If the bucket already contains an element, linearly traverse forward from the conflict position (usually with a step size of $1$) until an empty bucket is found, then insert the element.
-- **Searching for elements**: If a hash collision is encountered, use the same step size to linearly traverse forward until the corresponding element is found and return `value`; if an empty bucket is encountered, it means the target element is not in the hash table, so return `None`.
+- **Inserting elements**: Compute the bucket index using the hash function. If the bucket is already occupied, continue probing forward from the collision position with a fixed step size (usually $1$) until an empty bucket is found, then insert the element there.
+- **Searching for elements**: If a collision occurs, continue probing forward with the same step size until the corresponding element is found and return its `value`; if an empty bucket is encountered, the target element is not in the hash table, so return `None`.
 
-Figure 6-6 shows the distribution of key-value pairs in an open addressing (linear probing) hash table. According to this hash function, keys with the same last two digits will be mapped to the same bucket. Through linear probing, they are stored sequentially in that bucket and the buckets below it.
+Figure 6-6 shows the distribution of key-value pairs in an open-addressing hash table that uses linear probing. Under this hash function, keys with the same last two digits are mapped to the same bucket. Linear probing then places them in that bucket and the subsequent buckets.
 
 ![Distribution of key-value pairs in open addressing (linear probing) hash table](hash_collision.assets/hash_table_linear_probing.png){ class="animation-figure" }
 
 <p align="center"> Figure 6-6 &nbsp; Distribution of key-value pairs in open addressing (linear probing) hash table </p>
 
-However, **linear probing is prone to create "clustering"**. Specifically, the longer the continuously occupied positions in the array, the greater the probability of hash collisions occurring in these continuous positions, further promoting clustering growth at that position, forming a vicious cycle, and ultimately leading to degraded efficiency of insertion, deletion, query, and update operations.
+However, **linear probing is prone to clustering**. Specifically, the longer a contiguous occupied region in the array becomes, the more likely new collisions are to occur within that region. This in turn makes the cluster grow even further, creating a vicious cycle that gradually degrades the efficiency of insertion, deletion, lookup, and update 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 empty bucket inaccessible. The program may incorrectly assume these elements do not exist, as shown in Figure 6-7.
+It's important to note that **we cannot directly delete elements from an open-addressing hash table**. Deleting an element creates an empty bucket `None` in the array. During lookup, once linear probing reaches that empty bucket, it stops, which means any elements stored farther along the probe sequence become unreachable. As a result, the program may incorrectly conclude that those elements do not exist, as shown in Figure 6-7.
 
 ![Query issues caused by deletion in open addressing](hash_collision.assets/hash_table_open_addressing_deletion.png){ class="animation-figure" }
 
 <p align="center"> Figure 6-7 &nbsp; Query issues caused by deletion in open addressing </p>
 
-To solve this problem, we can adopt the <u>lazy deletion</u> 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.
+To solve this problem, we can adopt <u>lazy deletion</u>: instead of directly removing an element from the hash table, **use a constant `TOMBSTONE` to mark the bucket**. Under this mechanism, both `None` and `TOMBSTONE` denote buckets that can accept key-value pairs. The difference is that when linear probing encounters `TOMBSTONE`, it must continue probing, because key-value pairs may still exist farther along the sequence.
 
-However, **lazy deletion may accelerate the performance degradation of the hash table**. Every deletion operation produces a deletion mark, and as `TOMBSTONE` increases, the search time will also increase because linear probing may need to skip multiple `TOMBSTONE` to find the target element.
+However, **lazy deletion may accelerate hash-table performance degradation**. Each deletion leaves behind a marker, and as the number of `TOMBSTONE` entries grows, search time increases as well, because linear probing may need to skip over multiple tombstones before finding the target element.
 
-To address this, consider recording the index of the first encountered `TOMBSTONE` during linear probing and swapping the searched target element with that `TOMBSTONE`. The benefit of doing this is that each time an element is queried or added, the element will be moved to a bucket closer to its ideal position (the starting point of probing), thereby optimizing query efficiency.
+To address this, we can record the index of the first `TOMBSTONE` encountered during linear probing and swap the found target element into that position. The benefit is that each query or insertion can move elements closer to their ideal positions, that is, closer to where probing begins, which improves lookup efficiency.
 
 The code below implements an open addressing (linear probing) hash table with lazy deletion. To make better use of the hash table space, we treat the hash table as a "circular array". When going beyond the end of the array, we return to the beginning and continue traversing.
 
@@ -3291,18 +3291,18 @@ However, quadratic probing is not perfect:
 - Clustering still exists, i.e., some positions are more likely to be occupied than others.
 - Due to the growth of squares, quadratic probing may not probe the entire hash table, meaning that even if there are empty buckets in the hash table, quadratic probing may not be able to access them.
 
-### 3. &nbsp; Double Hashing
+### 3. &nbsp; Multiple Hashing
 
-As the name suggests, the double hashing method uses multiple hash functions $f_1(x)$, $f_2(x)$, $f_3(x)$, $\dots$ for probing.
+As the name suggests, multiple hashing uses multiple hash functions $f_1(x)$, $f_2(x)$, $f_3(x)$, $\dots$ for probing.
 
 - **Inserting elements**: If hash function $f_1(x)$ encounters a conflict, try $f_2(x)$, and so on, until an empty position is found and the element is inserted.
 - **Searching for elements**: Search in the same order of hash functions until the target element is found and return it; if an empty position is encountered or all hash functions have been tried, it indicates the element is not in the hash table, then return `None`.
 
-Compared to linear probing, the double hashing method is less prone to clustering, but multiple hash functions introduce additional computational overhead.
+Compared with linear probing, multiple hashing is less prone to clustering, but using multiple hash functions introduces additional computational overhead.
 
 !!! tip
 
-    Please note that open addressing (linear probing, quadratic probing, and double hashing) hash tables all have the problem of "cannot directly delete elements".
+    Please note that hash tables based on open addressing, including linear probing, quadratic probing, and multiple hashing, all have the problem that elements cannot be deleted directly.
 
 ## 6.2.3 &nbsp; Choice of Programming Languages
 

en/docs/chapter_hashing/hash_map.md

@@ -4,9 +4,9 @@ comments: true
 
 # 6.1   Hash Table
 
-A <u>hash table</u>, also known as a <u>hash map</u>, establishes a mapping between keys `key` and values `value`, enabling efficient element retrieval. Specifically, when we input a key `key` into a hash table, we can retrieve the corresponding value `value` in $O(1)$ time.
+A <u>hash table</u>, also known as a <u>hash map</u>, stores mappings from keys `key` to values `value`, enabling efficient lookups. Specifically, given a key `key`, we can retrieve the corresponding value `value` from a hash table in $O(1)$ time.
 
-As shown in Figure 6-1, given $n$ students, each with two pieces of data: "name" and "student ID". If we want to implement a query function that "inputs a student ID and returns the corresponding name", we can use the hash table shown below.
+As shown below, suppose we have $n$ students, each with two pieces of information: a name and a student ID. If we want to support the query "given a student ID, return the corresponding name," we can use the hash table shown below.
 
 ![Abstract representation of a hash table](hash_map.assets/hash_table_lookup.png){ class="animation-figure" }
 
@@ -30,7 +30,7 @@ In addition to hash tables, arrays and linked lists can also implement query fun
 
 </div>
 
-As observed, **the time complexity for insertion, deletion, search, and modification operations in a hash table is $O(1)$**, which is very efficient.
+As we can see, **insertion, deletion, lookup, and update operations in a hash table all have time complexity $O(1)$**, making hash tables highly efficient.
 
 ## 6.1.1 &nbsp; Common Hash Table Operations
 
@@ -259,7 +259,7 @@ Common operations on hash tables include: initialization, query operations, addi
     map.insert(12836, "XiaoHa".to_string());
     map.insert(15937, "XiaoLuo".to_string());
     map.insert(16750, "XiaoSuan".to_string());
-    map.insert(13279, "XiaoFa".to_string());
+    map.insert(13276, "XiaoFa".to_string());
     map.insert(10583, "XiaoYa".to_string());
 
     /* Query operation */
@@ -550,22 +550,22 @@ There are three common ways to traverse a hash table: traversing key-value pairs
 
 ## 6.1.2 &nbsp; Simple Hash Table Implementation
 
-Let's first consider the simplest case: **implementing a hash table using only an array**. In a hash table, each empty position in the array is called a <u>bucket</u>, and each bucket can store a key-value pair. Therefore, the query operation is to find the bucket corresponding to `key` and retrieve the `value` from the bucket.
+Let's start with the simplest case: **implementing a hash table with just an array**. In a hash table, each empty slot in the array is called a <u>bucket</u>, and each bucket can store one key-value pair. A lookup therefore consists of finding the bucket for `key` and reading the `value` stored there.
 
-So how do we locate the corresponding bucket based on `key`? This is achieved through a <u>hash function</u>. The role of the hash function is to map a larger input space to a smaller output space. In a hash table, the input space is all `key`s, and the output space is all buckets (array indices). In other words, given a `key`, **we can use the hash function to obtain the storage location of the key-value pair corresponding to that `key` in the array**.
+So how do we find the right bucket for a given `key`? We do this with a <u>hash function</u>. A hash function maps a larger input space to a smaller output space. In a hash table, the input space is the set of all `key`s, and the output space is the set of all buckets (array indices). In other words, given a `key`, **the hash function tells us where the corresponding key-value pair should be stored in the array**.
 
-When inputting a `key`, the hash function's calculation process consists of the following two steps:
+Given a `key`, computing the bucket index involves the following two steps:
 
-1. Calculate the hash value through a hash algorithm `hash()`.
-2. Take the modulo of the hash value by the number of buckets (array length) `capacity` to obtain the bucket (array index) `index` corresponding to that `key`.
+1. Use a hash algorithm `hash()` to compute a hash value.
+2. Take that hash value modulo the number of buckets (array length), `capacity`, to obtain the bucket (array index) `index` corresponding to the `key`.
 
 ```shell
 index = hash(key) % capacity
 ```
 
-Subsequently, we can use `index` to access the corresponding bucket in the hash table and retrieve the `value`.
+We can then use `index` to access the corresponding bucket in the hash table and retrieve the `value`.
 
-Assuming the array length is `capacity = 100` and the hash algorithm is `hash(key) = key`, the hash function becomes `key % 100`. Figure 6-2 shows the working principle of the hash function using `key` as student ID and `value` as name.
+Suppose the array length is `capacity = 100` and the hash algorithm is `hash(key) = key`. Then the hash function is `key % 100`. Figure 6-2 illustrates how this hash function works, using student ID as `key` and name as `value`.
 
 ![Working principle of hash function](hash_map.assets/hash_function.png){ class="animation-figure" }
 
@@ -1753,7 +1753,7 @@ The following code implements a simple hash table. Here, we encapsulate `key` an
 
 ## 6.1.3 &nbsp; Hash Collision and Resizing
 
-Fundamentally, the role of a hash function is to map the input space consisting of all `key`s to the output space consisting of all array indices, and the input space is often much larger than the output space. Therefore, **theoretically there must be cases where "multiple inputs correspond to the same output"**.
+Fundamentally, a hash function maps the input space consisting of all `key`s to the output space consisting of all array indices, and the input space is often much larger than the output space. Therefore, **in theory, different inputs must sometimes map to the same output**.
 
 For the hash function in the above example, when the input `key`s have the same last two digits, the hash function produces the same output. For example, when querying two students with IDs 12836 and 20336, we get:
 
@@ -1762,7 +1762,7 @@ For the hash function in the above example, when the input `key`s have the same
 20336 % 100 = 36
 ```
 
-As shown in Figure 6-3, two student IDs point to the same name, which is obviously incorrect. We call this situation where multiple inputs correspond to the same output a <u>hash collision</u>.
+As shown below, two student IDs now point to the same name, which is clearly incorrect. We call this situation, where multiple inputs map to the same output, a <u>hash collision</u>.
 
 ![Hash collision example](hash_map.assets/hash_collision.png){ class="animation-figure" }
 
@@ -1776,6 +1776,6 @@ As shown in Figure 6-4, before expansion, the key-value pairs `(136, A)` and `(2
 
 <p align="center"> Figure 6-4 &nbsp; Hash table resizing </p>
 
-Similar to array expansion, hash table expansion requires migrating all key-value pairs from the original hash table to the new hash table, which is very time-consuming. Moreover, since the hash table capacity `capacity` changes, we need to recalculate the storage locations of all key-value pairs through the hash function, further increasing the computational overhead of the expansion process. For this reason, programming languages typically reserve a sufficiently large hash table capacity to prevent frequent expansion.
+Like resizing an array, resizing a hash table requires migrating all key-value pairs from the original table to the new table, which is expensive. In addition, because the hash table capacity `capacity` changes, we must recompute the storage location of every key-value pair using the hash function, which further increases the cost of resizing. For this reason, programming languages typically reserve a sufficiently large hash table capacity to avoid frequent resizing.
 
-The <u>load factor</u> is an important concept for hash tables. It is defined as the number of elements in the hash table divided by the number of buckets, and is used to measure the severity of hash collisions. **It is also commonly used as a trigger condition for hash table expansion**. For example, in Java, when the load factor exceeds $0.75$, the system will expand the hash table to $2$ times its original size.
+The <u>load factor</u> is an important concept in hash tables. It is defined as the number of elements in the hash table divided by the number of buckets and is used to measure the severity of hash collisions. **It is also commonly used as a threshold for triggering hash table resizing**. For example, in Java, when the load factor exceeds $0.75$, the system expands the hash table to twice its original size.

en/docs/chapter_hashing/index.md

@@ -3,15 +3,15 @@ comments: true
 icon: material/table-search
 ---
 
-# Chapter 6.   Hashing
+# Chapter 6.   Hash Table
 
-![Hashing](../assets/covers/chapter_hashing.jpg){ class="cover-image" }
+![Hash Table](../assets/covers/chapter_hashing.jpg){ class="cover-image" }
 
 !!! abstract
 
     In the world of computing, a hash table is like a clever librarian.
 
-    They know how to calculate call numbers, enabling them to quickly locate the target book.
+    It knows how to compute call numbers, allowing it to quickly locate the desired book.
 
 ## Chapter contents
 

en/docs/chapter_hashing/summary.md

@@ -12,7 +12,7 @@ comments: true
 - 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 expansion can mitigate hash collisions. Similar to array expansion, hash table expansion is costly.
 - The load factor, defined as the number of elements divided by the number of buckets, reflects the severity of hash collisions and is often used as a condition to trigger hash table expansion.
-- Separate chaining addresses hash collisions by converting each element into a linked list, storing all colliding elements in the same linked list. However, excessively long linked lists can reduce query efficiency, which can be improved by converting the linked lists into red-black trees.
+- Separate chaining addresses hash collisions by storing all colliding elements in the same linked list. However, excessively long linked lists can reduce query efficiency, which can be improved by further converting the linked lists into red-black trees.
 - Open addressing handles hash collisions through multiple probing. Linear probing uses a fixed step size but cannot delete elements and is prone to clustering. Double hashing uses multiple hash functions for probing, which reduces clustering compared to linear probing but increases computational overhead.
 - Different programming languages adopt various hash table implementations. For example, Java's `HashMap` uses separate 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.
@@ -49,3 +49,7 @@ During the search process, the hash function points to the corresponding bucket
 **Q**: Why can expanding 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 expanding, 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 expansion, thereby mitigating hash collisions.
+
+**Q**: If the goal is efficient access, why not just use an array directly?
+
+When the `key` values are continuous integers within a small range, an array is indeed a simple and efficient choice. But when the `key` is of another type, such as a string, we need a hash function to map the `key` to an array index and then store the element in a bucket array. That structure is precisely what a hash table is.