translation: refine translation of hash_map.md (krahets#1483)

* Update hash_map.md

* Update hash_map.md

* Update hash_map.md to improve concise

en/docs/chapter_hashing/hash_map.md

@@ -1,16 +1,16 @@
 # Hash table
 
-A <u>hash table</u>, also known as a <u>hash map</u>, is a data structure that establishes a mapping between keys and values, enabling efficient element retrieval. Specifically, when we input a `key` into the hash table, we can retrive the corresponding `value` in $O(1)$ time complexity.
+A <u>hash table</u>, also known as a <u>hash map</u>, is a data structure that establishes a mapping between keys and values, enabling efficient element retrieval. Specifically, when we input a `key` into the hash table, we can retrieve the corresponding `value` in $O(1)$ time complexity.
 
 As shown in the figure below, given $n$ students, each student has two data fields: "Name" and "Student ID". If we want to implement a query function that takes a student ID as input and returns the corresponding name, we can use the hash table shown in the figure below.
 
 ![Abstract representation of a hash table](hash_map.assets/hash_table_lookup.png)
 
 In addition to hash tables, arrays and linked lists can also be used to implement query functionality, but the time complexity is different. Their efficiency is compared in the table below:
 
-- **Inserting elements**: Simply append the element to the tail of the array (or linked list). The time complexity of this operation is $O(1)$.
-- **Searching for elements**: As the array (or linked list) is unsorted, searching for an element requires traversing through all of the elements. The time complexity of this operation is $O(n)$.
-- **Deleting elements**: To remove an element, we first need to locate it. Then, we delete it from the array (or linked list). The time complexity of this operation is $O(n)$.
+- **Inserting an element**: Simply append the element to the tail of the array (or linked list). The time complexity of this operation is $O(1)$.
+- **Searching for an element**: As the array (or linked list) is unsorted, searching for an element requires traversing through all of the elements. The time complexity of this operation is $O(n)$.
+- **Deleting an element**: To remove an element, we first need to locate it. Then, we delete it from the array (or linked list). The time complexity of this operation is $O(n)$.
 
 <p align="center"> Table <id> &nbsp; Comparison of time efficiency for common operations </p>
 
@@ -20,7 +20,7 @@ In addition to hash tables, arrays and linked lists can also be used to implemen
 | Insert Elements    | $O(1)$ | $O(1)$      | $O(1)$     |
 | Delete Elements | $O(n)$ | $O(n)$      | $O(1)$     |
 
-It can be seen that **the time complexity for operations (insertion, deletion, searching, and modification) in a hash table is $O(1)$**, which is highly efficient.
+As observed, **the time complexity for operations (insertion, deletion, searching, and modification) in a hash table is $O(1)$**, which is highly efficient.
 
 ## Common operations of hash table
 
@@ -56,7 +56,7 @@ Common operations of a hash table include: initialization, querying, adding key-
     unordered_map<int, string> map;
 
     /* Add operation */
-    // Add key-value pair (key, value) to the hash table
+    // Add key-value pair (key, value) to hash table
     map[12836] = "Xiao Ha";
     map[15937] = "Xiao Luo";
     map[16750] = "Xiao Suan";
@@ -79,7 +79,7 @@ Common operations of a hash table include: initialization, querying, adding key-
     Map<Integer, String> map = new HashMap<>();
 
     /* Add operation */
-    // Add key-value pair (key, value) to the hash table
+    // Add key-value pair (key, value) to hash table
     map.put(12836, "Xiao Ha");   
     map.put(15937, "Xiao Luo");   
     map.put(16750, "Xiao Suan");   
@@ -101,7 +101,7 @@ Common operations of a hash table include: initialization, querying, adding key-
     /* Initialize hash table */
     Dictionary<int, string> map = new() {
         /* Add operation */
-        // Add key-value pair (key, value) to the hash table
+        // Add key-value pair (key, value) to hash table
         { 12836, "Xiao Ha" },
         { 15937, "Xiao Luo" },
         { 16750, "Xiao Suan" },
@@ -125,7 +125,7 @@ Common operations of a hash table include: initialization, querying, adding key-
     hmap := make(map[int]string)
 
     /* Add operation */
-    // Add key-value pair (key, value) to the hash table
+    // Add key-value pair (key, value) to hash table
     hmap[12836] = "Xiao Ha"
     hmap[15937] = "Xiao Luo"
     hmap[16750] = "Xiao Suan"
@@ -148,7 +148,7 @@ Common operations of a hash table include: initialization, querying, adding key-
     var map: [Int: String] = [:]
 
     /* Add operation */
-    // Add key-value pair (key, value) to the hash table
+    // Add key-value pair (key, value) to hash table
     map[12836] = "Xiao Ha"
     map[15937] = "Xiao Luo"
     map[16750] = "Xiao Suan"
@@ -192,7 +192,7 @@ Common operations of a hash table include: initialization, querying, adding key-
     /* Initialize hash table */
     const map = new Map<number, string>();
     /* Add operation */
-    // Add key-value pair (key, value) to the hash table
+    // Add key-value pair (key, value) to hash table
     map.set(12836, 'Xiao Ha');
     map.set(15937, 'Xiao Luo');
     map.set(16750, 'Xiao Suan');
@@ -220,7 +220,7 @@ Common operations of a hash table include: initialization, querying, adding key-
     Map<int, String> map = {};
 
     /* Add operation */
-    // Add key-value pair (key, value) to the hash table
+    // Add key-value pair (key, value) to hash table
     map[12836] = "Xiao Ha";
     map[15937] = "Xiao Luo";
     map[16750] = "Xiao Suan";
@@ -245,7 +245,7 @@ Common operations of a hash table include: initialization, querying, adding key-
     let mut map: HashMap<i32, String> = HashMap::new();
 
     /* Add operation */
-    // Add key-value pair (key, value) to the hash table
+    // Add key-value pair (key, value) to hash table
     map.insert(12836, "Xiao Ha".to_string());
     map.insert(15937, "Xiao Luo".to_string());
     map.insert(16750, "Xiao Suan".to_string());
@@ -490,10 +490,10 @@ First, let's consider the simplest case: **implementing a hash table using only
 
 So, how do we locate the corresponding bucket based on the `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 consists of all the keys, and the output space consists of all the buckets (array indices). In other words, given a `key`, **we can use the hash function to determine the storage location of the corresponding key-value pair in the array**.
 
-When given a `key`, the calculation process of the hash function consists of the following two steps:
+With a given `key`, the calculation of the hash function consists of two steps:
 
 1. Calculate the hash value by using a certain hash algorithm `hash()`.
-2. Take the modulus of the hash value with the bucket count (array length) `capacity` to obtain the array `index` corresponding to that key.
+2. Take the modulus of the hash value with the bucket count (array length) `capacity` to obtain the array `index` corresponding to the key.
 
 ```shell
 index = hash(key) % capacity