mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-16 08:56:05 +00:00
Revisit the English version (#1835)
* Review the English version using Claude-4.5. * Update mkdocs.yml * Align the section titles. * Bug fixes
This commit is contained in:
Yudong Jin
+175
-109
@@ -1,30 +1,30 @@
|
||||
# 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 retrieve the corresponding `value` in $O(1)$ time complexity.
|
||||
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.
|
||||
|
||||
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.
|
||||
As shown in the figure below, 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.
|
||||
|
||||
|
||||
|
||||
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:
|
||||
In addition to hash tables, arrays and linked lists can also implement query functionality. Their efficiency comparison is shown in the following table.
|
||||
|
||||
- **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)$.
|
||||
- **Adding elements**: Simply add elements to the end of the array (linked list), using $O(1)$ time.
|
||||
- **Querying elements**: Since the array (linked list) is unordered, all elements need to be traversed, using $O(n)$ time.
|
||||
- **Deleting elements**: The element must first be located, then deleted from the array (linked list), using $O(n)$ time.
|
||||
|
||||
<p align="center"> Table <id> Comparison of time efficiency for common operations </p>
|
||||
<p align="center"> Table <id> Comparison of element query efficiency </p>
|
||||
|
||||
| | Array | Linked List | Hash Table |
|
||||
| -------------- | ------ | ----------- | ---------- |
|
||||
| Search Elements | $O(n)$ | $O(n)$ | $O(1)$ |
|
||||
| Insert Elements | $O(1)$ | $O(1)$ | $O(1)$ |
|
||||
| Delete Elements | $O(n)$ | $O(n)$ | $O(1)$ |
|
||||
| | 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)$ |
|
||||
|
||||
As observed, **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 insertion, deletion, search, and modification operations in a hash table is $O(1)$**, which is very efficient.
|
||||
|
||||
## Common operations of hash table
|
||||
## Common hash table operations
|
||||
|
||||
Common operations of a hash table include: initialization, querying, adding key-value pairs, and deleting key-value pairs. Here is an example code:
|
||||
Common operations on hash tables include: initialization, query operations, adding key-value pairs, and deleting key-value pairs. Example code is as follows:
|
||||
|
||||
=== "Python"
|
||||
|
||||
@@ -33,15 +33,15 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
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"
|
||||
# Add key-value pair (key, value) to hash table
|
||||
hmap[12836] = "小哈"
|
||||
hmap[15937] = "小啰"
|
||||
hmap[16750] = "小算"
|
||||
hmap[13276] = "小法"
|
||||
hmap[10583] = "小鸭"
|
||||
|
||||
# Query operation
|
||||
# Input key into hash table, get value
|
||||
# Input key into hash table to get value
|
||||
name: str = hmap[15937]
|
||||
|
||||
# Delete operation
|
||||
@@ -57,14 +57,14 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to hash table
|
||||
map[12836] = "Xiao Ha";
|
||||
map[15937] = "Xiao Luo";
|
||||
map[16750] = "Xiao Suan";
|
||||
map[13276] = "Xiao Fa";
|
||||
map[10583] = "Xiao Ya";
|
||||
map[12836] = "小哈";
|
||||
map[15937] = "小啰";
|
||||
map[16750] = "小算";
|
||||
map[13276] = "小法";
|
||||
map[10583] = "小鸭";
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
string name = map[15937];
|
||||
|
||||
/* Delete operation */
|
||||
@@ -80,14 +80,14 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to hash table
|
||||
map.put(12836, "Xiao Ha");
|
||||
map.put(15937, "Xiao Luo");
|
||||
map.put(16750, "Xiao Suan");
|
||||
map.put(13276, "Xiao Fa");
|
||||
map.put(10583, "Xiao Ya");
|
||||
map.put(12836, "小哈");
|
||||
map.put(15937, "小啰");
|
||||
map.put(16750, "小算");
|
||||
map.put(13276, "小法");
|
||||
map.put(10583, "小鸭");
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
String name = map.get(15937);
|
||||
|
||||
/* Delete operation */
|
||||
@@ -102,15 +102,15 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
Dictionary<int, string> map = new() {
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to hash table
|
||||
{ 12836, "Xiao Ha" },
|
||||
{ 15937, "Xiao Luo" },
|
||||
{ 16750, "Xiao Suan" },
|
||||
{ 13276, "Xiao Fa" },
|
||||
{ 10583, "Xiao Ya" }
|
||||
{ 12836, "小哈" },
|
||||
{ 15937, "小啰" },
|
||||
{ 16750, "小算" },
|
||||
{ 13276, "小法" },
|
||||
{ 10583, "小鸭" }
|
||||
};
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
string name = map[15937];
|
||||
|
||||
/* Delete operation */
|
||||
@@ -126,14 +126,14 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to hash table
|
||||
hmap[12836] = "Xiao Ha"
|
||||
hmap[15937] = "Xiao Luo"
|
||||
hmap[16750] = "Xiao Suan"
|
||||
hmap[13276] = "Xiao Fa"
|
||||
hmap[10583] = "Xiao Ya"
|
||||
hmap[12836] = "小哈"
|
||||
hmap[15937] = "小啰"
|
||||
hmap[16750] = "小算"
|
||||
hmap[13276] = "小法"
|
||||
hmap[10583] = "小鸭"
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
name := hmap[15937]
|
||||
|
||||
/* Delete operation */
|
||||
@@ -149,14 +149,14 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to hash table
|
||||
map[12836] = "Xiao Ha"
|
||||
map[15937] = "Xiao Luo"
|
||||
map[16750] = "Xiao Suan"
|
||||
map[13276] = "Xiao Fa"
|
||||
map[10583] = "Xiao Ya"
|
||||
map[12836] = "小哈"
|
||||
map[15937] = "小啰"
|
||||
map[16750] = "小算"
|
||||
map[13276] = "小法"
|
||||
map[10583] = "小鸭"
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
let name = map[15937]!
|
||||
|
||||
/* Delete operation */
|
||||
@@ -170,15 +170,15 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
/* Initialize hash table */
|
||||
const map = new Map();
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to the hash table
|
||||
map.set(12836, 'Xiao Ha');
|
||||
map.set(15937, 'Xiao Luo');
|
||||
map.set(16750, 'Xiao Suan');
|
||||
map.set(13276, 'Xiao Fa');
|
||||
map.set(10583, 'Xiao Ya');
|
||||
// Add key-value pair (key, value) to hash table
|
||||
map.set(12836, '小哈');
|
||||
map.set(15937, '小啰');
|
||||
map.set(16750, '小算');
|
||||
map.set(13276, '小法');
|
||||
map.set(10583, '小鸭');
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
let name = map.get(15937);
|
||||
|
||||
/* Delete operation */
|
||||
@@ -193,23 +193,23 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
const map = new Map<number, string>();
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to hash table
|
||||
map.set(12836, 'Xiao Ha');
|
||||
map.set(15937, 'Xiao Luo');
|
||||
map.set(16750, 'Xiao Suan');
|
||||
map.set(13276, 'Xiao Fa');
|
||||
map.set(10583, 'Xiao Ya');
|
||||
console.info('\nAfter adding, the hash table is\nKey -> Value');
|
||||
map.set(12836, '小哈');
|
||||
map.set(15937, '小啰');
|
||||
map.set(16750, '小算');
|
||||
map.set(13276, '小法');
|
||||
map.set(10583, '小鸭');
|
||||
console.info('\nAfter adding, hash table is\nKey -> Value');
|
||||
console.info(map);
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
let name = map.get(15937);
|
||||
console.info('\nInput student number 15937, query name ' + name);
|
||||
console.info('\nInput student ID 15937, queried name ' + name);
|
||||
|
||||
/* Delete operation */
|
||||
// Delete key-value pair (key, value) from hash table
|
||||
map.delete(10583);
|
||||
console.info('\nAfter deleting 10583, the hash table is\nKey -> Value');
|
||||
console.info('\nAfter deleting 10583, hash table is\nKey -> Value');
|
||||
console.info(map);
|
||||
```
|
||||
|
||||
@@ -221,14 +221,14 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to hash table
|
||||
map[12836] = "Xiao Ha";
|
||||
map[15937] = "Xiao Luo";
|
||||
map[16750] = "Xiao Suan";
|
||||
map[13276] = "Xiao Fa";
|
||||
map[10583] = "Xiao Ya";
|
||||
map[12836] = "小哈";
|
||||
map[15937] = "小啰";
|
||||
map[16750] = "小算";
|
||||
map[13276] = "小法";
|
||||
map[10583] = "小鸭";
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
String name = map[15937];
|
||||
|
||||
/* Delete operation */
|
||||
@@ -246,14 +246,14 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
|
||||
/* Add operation */
|
||||
// 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());
|
||||
map.insert(13279, "Xiao Fa".to_string());
|
||||
map.insert(10583, "Xiao Ya".to_string());
|
||||
map.insert(12836, "小哈".to_string());
|
||||
map.insert(15937, "小啰".to_string());
|
||||
map.insert(16750, "小算".to_string());
|
||||
map.insert(13279, "小法".to_string());
|
||||
map.insert(10583, "小鸭".to_string());
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table, get value
|
||||
// Input key into hash table to get value
|
||||
let _name: Option<&String> = map.get(&15937);
|
||||
|
||||
/* Delete operation */
|
||||
@@ -270,7 +270,47 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
=== "Kotlin"
|
||||
|
||||
```kotlin title="hash_map.kt"
|
||||
/* Initialize hash table */
|
||||
val map = HashMap<Int,String>()
|
||||
|
||||
/* Add operation */
|
||||
// Add key-value pair (key, value) to hash table
|
||||
map[12836] = "小哈"
|
||||
map[15937] = "小啰"
|
||||
map[16750] = "小算"
|
||||
map[13276] = "小法"
|
||||
map[10583] = "小鸭"
|
||||
|
||||
/* Query operation */
|
||||
// Input key into hash table to get value
|
||||
val name = map[15937]
|
||||
|
||||
/* Delete operation */
|
||||
// Delete key-value pair (key, value) from hash table
|
||||
map.remove(10583)
|
||||
```
|
||||
|
||||
=== "Ruby"
|
||||
|
||||
```ruby title="hash_map.rb"
|
||||
# Initialize hash table
|
||||
hmap = {}
|
||||
|
||||
# Add operation
|
||||
# Add key-value pair (key, value) to hash table
|
||||
hmap[12836] = "小哈"
|
||||
hmap[15937] = "小啰"
|
||||
hmap[16750] = "小算"
|
||||
hmap[13276] = "小法"
|
||||
hmap[10583] = "小鸭"
|
||||
|
||||
# Query operation
|
||||
# Input key into hash table to get value
|
||||
name = hmap[15937]
|
||||
|
||||
# Delete operation
|
||||
# Delete key-value pair (key, value) from hash table
|
||||
hmap.delete(10583)
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
@@ -279,11 +319,11 @@ Common operations of a hash table include: initialization, querying, adding key-
|
||||
|
||||
```
|
||||
|
||||
??? pythontutor "Code Visualization"
|
||||
??? pythontutor "Visualized Execution"
|
||||
|
||||
https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%9F%A5%E8%AF%A2%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%90%91%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E8%BE%93%E5%85%A5%E9%94%AE%20key%20%EF%BC%8C%E5%BE%97%E5%88%B0%E5%80%BC%20value%0A%20%20%20%20name%20%3D%20hmap%5B15937%5D%0A%20%20%20%20%0A%20%20%20%20%23%20%E5%88%A0%E9%99%A4%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E5%88%A0%E9%99%A4%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap.pop%2810583%29&cumulative=false&curInstr=2&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
|
||||
|
||||
There are three common ways to traverse a hash table: traversing key-value pairs, traversing keys, and traversing values. Here is an example code:
|
||||
There are three common ways to traverse a hash table: traversing key-value pairs, traversing keys, and traversing values. Example code is as follows:
|
||||
|
||||
=== "Python"
|
||||
|
||||
@@ -428,17 +468,17 @@ There are three common ways to traverse a hash table: traversing key-value pairs
|
||||
/* Traverse hash table */
|
||||
// Traverse key-value pairs Key->Value
|
||||
map.forEach((key, value) {
|
||||
print('$key -> $value');
|
||||
print('$key -> $value');
|
||||
});
|
||||
|
||||
// Traverse keys only Key
|
||||
// Traverse keys only
|
||||
map.keys.forEach((key) {
|
||||
print(key);
|
||||
print(key);
|
||||
});
|
||||
|
||||
// Traverse values only Value
|
||||
// Traverse values only
|
||||
map.values.forEach((value) {
|
||||
print(value);
|
||||
print(value);
|
||||
});
|
||||
```
|
||||
|
||||
@@ -451,12 +491,12 @@ There are three common ways to traverse a hash table: traversing key-value pairs
|
||||
println!("{key} -> {value}");
|
||||
}
|
||||
|
||||
// Traverse keys only Key
|
||||
// Traverse keys only
|
||||
for key in map.keys() {
|
||||
println!("{key}");
|
||||
println!("{key}");
|
||||
}
|
||||
|
||||
// Traverse values only Value
|
||||
// Traverse values only
|
||||
for value in map.values() {
|
||||
println!("{value}");
|
||||
}
|
||||
@@ -471,41 +511,67 @@ There are three common ways to traverse a hash table: traversing key-value pairs
|
||||
=== "Kotlin"
|
||||
|
||||
```kotlin title="hash_map.kt"
|
||||
/* Traverse hash table */
|
||||
// Traverse key-value pairs key->value
|
||||
for ((key, value) in map) {
|
||||
println("$key -> $value")
|
||||
}
|
||||
// Traverse keys only
|
||||
for (key in map.keys) {
|
||||
println(key)
|
||||
}
|
||||
// Traverse values only
|
||||
for (_val in map.values) {
|
||||
println(_val)
|
||||
}
|
||||
```
|
||||
|
||||
=== "Ruby"
|
||||
|
||||
```ruby title="hash_map.rb"
|
||||
# Traverse hash table
|
||||
# Traverse key-value pairs key->value
|
||||
hmap.entries.each { |key, value| puts "#{key} -> #{value}" }
|
||||
|
||||
# Traverse keys only
|
||||
hmap.keys.each { |key| puts key }
|
||||
|
||||
# Traverse values only
|
||||
hmap.values.each { |val| puts val }
|
||||
```
|
||||
|
||||
=== "Zig"
|
||||
|
||||
```zig title="hash_map.zig"
|
||||
// Zig example is not provided
|
||||
|
||||
```
|
||||
|
||||
??? pythontutor "Code Visualization"
|
||||
??? pythontutor "Visualized Execution"
|
||||
|
||||
https://pythontutor.com/render.html#code=%22%22%22Driver%20Code%22%22%22%0Aif%20__name__%20%3D%3D%20%22__main__%22%3A%0A%20%20%20%20%23%20%E5%88%9D%E5%A7%8B%E5%8C%96%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20hmap%20%3D%20%7B%7D%0A%20%20%20%20%0A%20%20%20%20%23%20%E6%B7%BB%E5%8A%A0%E6%93%8D%E4%BD%9C%0A%20%20%20%20%23%20%E5%9C%A8%E5%93%88%E5%B8%8C%E8%A1%A8%E4%B8%AD%E6%B7%BB%E5%8A%A0%E9%94%AE%E5%80%BC%E5%AF%B9%20%28key,%20value%29%0A%20%20%20%20hmap%5B12836%5D%20%3D%20%22%E5%B0%8F%E5%93%88%22%0A%20%20%20%20hmap%5B15937%5D%20%3D%20%22%E5%B0%8F%E5%95%B0%22%0A%20%20%20%20hmap%5B16750%5D%20%3D%20%22%E5%B0%8F%E7%AE%97%22%0A%20%20%20%20hmap%5B13276%5D%20%3D%20%22%E5%B0%8F%E6%B3%95%22%0A%20%20%20%20hmap%5B10583%5D%20%3D%20%22%E5%B0%8F%E9%B8%AD%22%0A%20%20%20%20%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E5%93%88%E5%B8%8C%E8%A1%A8%0A%20%20%20%20%23%20%E9%81%8D%E5%8E%86%E9%94%AE%E5%80%BC%E5%AF%B9%20key-%3Evalue%0A%20%20%20%20for%20key,%20value%20in%20hmap.items%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key,%20%22-%3E%22,%20value%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E9%94%AE%20key%0A%20%20%20%20for%20key%20in%20hmap.keys%28%29%3A%0A%20%20%20%20%20%20%20%20print%28key%29%0A%20%20%20%20%23%20%E5%8D%95%E7%8B%AC%E9%81%8D%E5%8E%86%E5%80%BC%20value%0A%20%20%20%20for%20value%20in%20hmap.values%28%29%3A%0A%20%20%20%20%20%20%20%20print%28value%29&cumulative=false&curInstr=8&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=311&rawInputLstJSON=%5B%5D&textReferences=false
|
||||
|
||||
## Simple implementation of a hash table
|
||||
## Simple hash table implementation
|
||||
|
||||
First, let's consider the simplest case: **implementing a hash table using only one array**. In the hash table, each empty slot in the array is called a <u>bucket</u>, and each bucket can store a key-value pair. Therefore, the query operation involves finding the bucket corresponding to the `key` and retrieving the `value` from it.
|
||||
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.
|
||||
|
||||
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**.
|
||||
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**.
|
||||
|
||||
With a given `key`, the calculation of the hash function consists of two steps:
|
||||
When inputting a `key`, the hash function's calculation process consists of the following 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 the key.
|
||||
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`.
|
||||
|
||||
```shell
|
||||
index = hash(key) % capacity
|
||||
```
|
||||
|
||||
Afterward, we can use the `index` to access the corresponding bucket in the hash table and thereby retrieve the `value`.
|
||||
Subsequently, we can use `index` to access the corresponding bucket in the hash table and retrieve the `value`.
|
||||
|
||||
Let's assume that the array length is `capacity = 100`, and the hash algorithm is defined as `hash(key) = key`. Therefore, the hash function can be expressed as `key % 100`. The following figure illustrates the working principle of the hash function using `key` as student ID and `value` as name.
|
||||
Assuming the array length is `capacity = 100` and the hash algorithm is `hash(key) = key`, the hash function becomes `key % 100`. The figure below shows the working principle of the hash function using `key` as student ID and `value` as name.
|
||||
|
||||
|
||||
|
||||
The following code implements a simple hash table. Here, we encapsulate `key` and `value` into a class `Pair` to represent the key-value pair.
|
||||
The following code implements a simple hash table. Here, we encapsulate `key` and `value` into a class `Pair` to represent a key-value pair.
|
||||
|
||||
```src
|
||||
[file]{array_hash_map}-[class]{array_hash_map}-[func]{}
|
||||
@@ -513,25 +579,25 @@ The following code implements a simple hash table. Here, we encapsulate `key` an
|
||||
|
||||
## Hash collision and resizing
|
||||
|
||||
Essentially, the role of the hash function is to map the entire input space of all keys to the output space of all array indices. However, the input space is often much larger than the output space. Therefore, **theoretically, there will always be cases where "multiple inputs correspond to the same output"**.
|
||||
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"**.
|
||||
|
||||
In the example above, with the given hash function, when the last two digits of the input `key` are the same, the hash function produces the same output. For instance, when querying two students with student IDs 12836 and 20336, we find:
|
||||
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:
|
||||
|
||||
```shell
|
||||
12836 % 100 = 36
|
||||
20336 % 100 = 36
|
||||
```
|
||||
|
||||
As shown in the figure below, both student IDs point to the same name, which is obviously incorrect. This situation where multiple inputs correspond to the same output is called <u>hash collision</u>.
|
||||
As shown in the figure below, 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>.
|
||||
|
||||
|
||||
|
||||
|
||||
It is easy to understand that as the capacity $n$ of the hash table increases, the probability of multiple keys being assigned to the same bucket decreases, resulting in fewer collisions. Therefore, **we can reduce hash collisions by resizing the hash table**.
|
||||
It's easy to see that the larger the hash table capacity $n$, the lower the probability that multiple `key`s will be assigned to the same bucket, and the fewer collisions. Therefore, **we can reduce hash collisions by expanding the hash table**.
|
||||
|
||||
As shown in the figure below, before resizing, the key-value pairs `(136, A)` and `(236, D)` collide. However, after resizing, the collision is resolved.
|
||||
As shown in the figure below, before expansion, the key-value pairs `(136, A)` and `(236, D)` collided, but after expansion, the collision disappears.
|
||||
|
||||
|
||||
|
||||
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` of the hash table changes, we need to recalculate the storage positions of all key-value pairs using the hash function, further increasing the computational overhead of the resizing process. Therefore, programming languages often allocate a sufficiently large capacity for the hash table to prevent frequent resizing.
|
||||
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.
|
||||
|
||||
The <u>load factor</u> is an important concept in 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 **often serves as a trigger for hash table resizing**. For example, in Java, when the load factor exceeds $0.75$, the system will resize the hash table to twice its original size.
|
||||
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.
|
||||
|
||||
Reference in New Issue
Block a user