yetao
/
hello-algo
mirror of https://github.com/krahets/hello-algo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

1. Update extra.css for overwrite

Browse Source 
the sections title color.
2. Add figures to hash collision.
3. Add inorder traversal in binary search tree.
pull/313/head
Yudong Jin 2 years ago
parent 08bfa0669a
commit f103fdecc9
7 changed files with 114 additions and 92 deletions
Show Stats Download Patch File Download Diff File

BIN
docs/chapter_hashing/hash_collision.assets/hash_collision_chaining.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 89 KiB

BIN
docs/chapter_hashing/hash_collision.assets/hash_collision_linear_probing.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 59 KiB

55
docs/chapter_hashing/hash_collision.md
Unescape View File

@ -2,45 +2,46 @@
comments: true
---
# 哈希冲突处理
# 哈希冲突
理想情况下，哈希函数应该为每个输入产生唯一的输出，使得 key 和 value 一一对应。而实际上，往往存在向哈希函数输入不同的 key 而产生相同输出的情况，这种情况被称为「哈希冲突 Hash Collision」。
理想情况下，哈希函数应该为每个输入产生唯一的输出，使得 key 和 value 一一对应。而实际上，往往存在向哈希函数输入不同的 key 而产生相同输出的情况，这种情况被称为「哈希冲突 Hash Collision」。哈希冲突会导致查询结果错误，从而严重影响哈希表的可用性。
**哈希冲突会严重影响哈希表的实用性**。试想一下，如果在哈希表中总是查找到错误的结果，那么我们肯定不会继续使用这样的数据结构了。
那么，为什么会出现哈希冲突呢？本质上看，**由于哈希函数的输入空间往往远大于输出空间**，因此不可避免地会出现多个输入产生相同输出的情况，即为哈希冲突。比如，输入空间是全体整数，输出空间是一个固定大小的桶（数组）的索引范围，那么必定会有多个整数同时映射到一个桶索引。
!!! question "为什么会出现哈希冲突？"
为了缓解哈希冲突，一方面，我们可以通过「哈希表扩容」来减小冲突概率。极端情况下，当输入空间和输出空间大小相等时，哈希表就等价于数组了，可谓“大力出奇迹”。
因为 **哈希函数的输入空间往往远大于输出空间**，所以不可避免地会出现多个输入产生相同输出的情况。比如，输入空间是全体整数，输出空间是一个固定大小的桶（数组）的索引范围，那么必定会有多个整数同时映射到一个桶索引。
另一方面，**考虑通过优化数据结构以缓解哈希冲突**，常见的方法有「链式地址」和「开放寻址」。
虽然理论上哈希冲突难以避免，**但我们仍然可以在数据结构层面上缓解哈希冲突所带来的负面影响**，尽量保证哈希表的增删查改操作效率。
## 哈希表扩容
常见的哈希冲突的解决方案有「链式地址」和「开放寻址」。
「负载因子 Load Factor」定义为 **哈希表中元素数量除以桶槽数量（即数组大小）**，代表哈希冲突的严重程度。
## 链式地址
**负载因子常用作哈希表扩容的触发条件**。比如在 Java 中，当负载因子 $> 0.75$ 时则触发扩容，将 HashMap 大小扩充至原先 $2$ 倍。
「链式地址」通过引入链表来解决哈希冲突问题，代价是占用空间变大，因为链表或二叉树包含结点指针，相比于数组更加耗费内存空间。
与数组扩容类似，**哈希表扩容操作的开销很大**，因为需要将所有键值对从原哈希表依次移动至新哈希表。
### 链表引入
## 链式地址
在原始哈希表中，一个桶地址只能存储一个元素（即键值对）。**考虑将桶地址内的单个元素转变成一个链表，将所有冲突元素都存储在一个链表中**，此时哈希表操作方法为：
在原始哈希表中，桶内的每个地址只能存储一个元素（即键值对）。**考虑将单个元素转化成一个链表，将所有冲突元素都存储在一个链表中**。
- **查询元素**：先将 key 输入到哈希函数得到桶地址（即访问链表头部），再遍历链表来确定对应的 value 。
- **添加元素**：先通过哈希函数访问链表头部，再将元素直接添加到链表头部即可。
- **删除元素**：同样先访问链表头部，再遍历链表查找对应元素，删除之即可。
![hash_collision_chaining](hash_collision.assets/hash_collision_chaining.png)
（图）
链式地址下，哈希表操作方法为：
### 二叉树引入
- **查询元素**：先将 key 输入到哈希函数得到桶内索引，即可访问链表头结点，再通过遍历链表查找对应 value 。
- **添加元素**：先通过哈希函数访问链表头部，再将结点（即键值对）添加到链表头部即可。
- **删除元素**：同样先根据哈希函数结果访问链表头部，再遍历链表查找对应结点，删除之即可。
引入链表虽然解决了哈希冲突，但查询效率也随之降低了，因为需要线性查找（即遍历链表）来确认对应元素。为了缓解此问题，**当某个桶地址内的链表太长时，可以把链表转化为「平衡二叉搜索树」**，将时间复杂度降低至 $O(\log n)$ 。
链式地址虽然解决了哈希冲突问题，但仍存在局限性，包括：
!!! note "工业界方案"
- **占用空间变大**，因为链表或二叉树包含结点指针，相比于数组更加耗费内存空间；
- **查询效率降低**，因为需要线性遍历链表来查找对应元素；
Java 使用了链式地址来解决哈希冲突。在 JDK 1.8 之后， HashMap 内长度大于 8 的链表会被转化为「红黑树」，以提升查找性能。
为了缓解时间效率问题，**可以把「链表」转化为「AVL 树」或「红黑树」**，将查询操作的时间复杂度优化至 $O(\log n)$ 。
## 开放寻址
「开放寻址」不引入额外数据结构，而是通过“向后探测”来解决哈希冲突。根据探测方法的不同，主要分为 **线性探测、平方探测、多次哈希**。
「开放寻址」不引入额外数据结构，而是通过“多次探测”来解决哈希冲突。根据探测方法的不同，主要分为 **线性探测、平方探测、多次哈希**。
### 线性探测
@ -53,16 +54,16 @@ comments: true
1. 找到对应元素，返回 value 即可；
2. 若遇到空位，则说明查找键值对不在哈希表中；
（图）
![hash_collision_linear_probing](hash_collision.assets/hash_collision_linear_probing.png)
线性探测有以下缺陷：
线性探测存在以下缺陷：
- **不能直接删除元素**。删除元素会导致桶内出现一个空位，在查找其他元素时，该空位有可能导致程序认为元素不存在（即上述第 `2.` 种情况）。因此需要借助一个标志位来标记删除元素。
- **容易产生聚集**。桶内被占用的连续位置越长，这些连续位置发生哈希冲突的可能性越大，从而进一步促进这一位置的“聚堆生长”，最终导致增删查改操作效率的劣化。
### 多次哈希
顾名思义，「多次哈希」的思路是基于多个哈希函数 $f_1(x)$ , $f_2(x)$ , $f_3(x)$ , $\cdots$ 进行探测。
顾名思义，「多次哈希」的思路是使用多个哈希函数 $f_1(x)$ , $f_2(x)$ , $f_3(x)$ , $\cdots$ 进行探测。
**插入元素**：若哈希函数 $f_1(x)$ 出现冲突，则尝试 $f_2(x)$ ，以此类推……直到找到空位后插入元素。
@ -72,3 +73,11 @@ comments: true
2. 到空位或已尝试所有哈希函数，说明哈希表中无此元素；
相比于「线性探测」，「多次哈希」方法更不容易产生聚集，代价是多个哈希函数增加了额外计算量。
!!! note "工业界方案"
Java 采用「链式地址」。在 JDK 1.8 之后，HashMap 内数组长度 $> 64$ 时，长度大于 8 的链表会被转化为「红黑树」，以提升查找性能。
Python 采用「开放寻址」。字典 dict 采用的是随机探测，即使用伪随机数来探测。

114
docs/chapter_hashing/hash_map.md
Unescape View File

@ -12,7 +12,7 @@ comments: true
<p align="center"> Fig. 哈希表抽象表示 </p>
## 哈希表优势
## 哈希表效率
除了哈希表之外，还可以使用以下数据结构来实现上述查询功能：
@ -42,7 +42,7 @@ comments: true
```java title="hash_map.java"
/* 初始化哈希表 */
Map<Integer, String> map = new HashMap<>();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(12836, "小哈");
@ -50,11 +50,11 @@ comments: true
map.put(16750, "小算");
map.put(13276, "小法");
map.put(10583, "小鸭");
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
String name = map.get(15937);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(10583);
@ -65,7 +65,7 @@ comments: true
```cpp title="hash_map.cpp"
/* 初始化哈希表 */
unordered_map<int, string> map;
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map[12836] = "小哈";
@ -73,11 +73,11 @@ comments: true
map[16750] = "小算";
map[13276] = "小法";
map[10583] = "小鸭";
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
string name = map[15937];
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.erase(10583);
@ -88,7 +88,7 @@ comments: true
```python title="hash_map.py"
""" 初始化哈希表 """
mapp = {}
""" 添加操作 """
# 在哈希表中添加键值对 (key, value)
mapp[12836] = "小哈"
@ -96,11 +96,11 @@ comments: true
mapp[16750] = "小算"
mapp[13276] = "小法"
mapp[10583] = "小鸭"
""" 查询操作 """
# 向哈希表输入键 key ，得到值 value
name = mapp[15937]
""" 删除操作 """
# 在哈希表中删除键值对 (key, value)
mapp.pop(10583)
@ -111,7 +111,7 @@ comments: true
```go title="hash_map.go"
/* 初始化哈希表 */
mapp := make(map[int]string)
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
mapp[12836] = "小哈"
@ -119,11 +119,11 @@ comments: true
mapp[16750] = "小算"
mapp[13276] = "小法"
mapp[10583] = "小鸭"
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
name := mapp[15937]
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
delete(mapp, 10583)
@ -141,11 +141,11 @@ comments: true
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鸭');
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.delete(10583);
@ -165,12 +165,12 @@ comments: true
map.set(10583, '小鸭');
console.info('\n添加完成后，哈希表为\nKey -> Value');
console.info(map);
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.delete(10583);
@ -181,7 +181,7 @@ comments: true
=== "C"
```c title="hash_map.c"
```
=== "C#"
@ -189,7 +189,7 @@ comments: true
```csharp title="hash_map.cs"
/* 初始化哈希表 */
Dictionary<int, String> map = new ();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.Add(12836, "小哈");
@ -197,11 +197,11 @@ comments: true
map.Add(16750, "小算");
map.Add(13276, "小法");
map.Add(10583, "小鸭");
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
String name = map[15937];
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.Remove(10583);
@ -212,7 +212,7 @@ comments: true
```swift title="hash_map.swift"
/* 初始化哈希表 */
var map: [Int: String] = [:]
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map[12836] = "小哈"
@ -220,11 +220,11 @@ comments: true
map[16750] = "小算"
map[13276] = "小法"
map[10583] = "小鸭"
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map[15937]!
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.removeValue(forKey: 10583)
@ -341,7 +341,7 @@ comments: true
=== "C"
```c title="hash_map.c"
```
=== "C#"
@ -413,7 +413,7 @@ $$
this.val = val;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
private List<Entry> bucket;
@ -424,13 +424,13 @@ $$
bucket.add(null);
}
}
/* 哈希函数 */
private int hashFunc(int key) {
int index = key % 100;
return index;
}
/* 查询操作 */
public String get(int key) {
int index = hashFunc(key);
@ -438,14 +438,14 @@ $$
if (pair == null) return null;
return pair.val;
}
/* 添加操作 */
public void put(int key, String val) {
Entry pair = new Entry(key, val);
int index = hashFunc(key);
bucket.set(index, pair);
}
/* 删除操作 */
public void remove(int key) {
int index = hashFunc(key);
@ -468,7 +468,7 @@ $$
this->val = val;
}
};
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
private:
@ -478,27 +478,27 @@ $$
// 初始化一个长度为 100 的桶（数组）
bucket= vector<Entry*>(100);
}
/* 哈希函数 */
int hashFunc(int key) {
int index = key % 100;
return index;
}
/* 查询操作 */
string get(int key) {
int index = hashFunc(key);
Entry* pair = bucket[index];
return pair->val;
}
/* 添加操作 */
void put(int key, string val) {
Entry* pair = new Entry(key, val);
int index = hashFunc(key);
bucket[index] = pair;
}
/* 删除操作 */
void remove(int key) {
int index = hashFunc(key);
@ -557,24 +557,24 @@ $$
key int
val string
}
/* 基于数组简易实现的哈希表 */
type arrayHashMap struct {
bucket []*entry
}
func newArrayHashMap() *arrayHashMap {
// 初始化一个长度为 100 的桶（数组）
bucket := make([]*entry, 100)
return &arrayHashMap{bucket: bucket}
}
/* 哈希函数 */
func (a *arrayHashMap) hashFunc(key int) int {
index := key % 100
return index
}
/* 查询操作 */
func (a *arrayHashMap) get(key int) string {
index := a.hashFunc(key)
@ -584,14 +584,14 @@ $$
}
return pair.val
}
/* 添加操作 */
func (a *arrayHashMap) put(key int, val string) {
pair := &entry{key: key, val: val}
index := a.hashFunc(key)
a.bucket[index] = pair
}
/* 删除操作 */
func (a *arrayHashMap) remove(key int) {
index := a.hashFunc(key)
@ -610,7 +610,7 @@ $$
this.val = val;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
#bucket;
@ -618,12 +618,12 @@ $$
// 初始化一个长度为 100 的桶（数组）
this.#bucket = new Array(100).fill(null);
}
/* 哈希函数 */
#hashFunc(key) {
return key % 100;
}
/* 查询操作 */
get(key) {
let index = this.#hashFunc(key);
@ -631,13 +631,13 @@ $$
if (entry === null) return null;
return entry.val;
}
/* 添加操作 */
set(key, val) {
let index = this.#hashFunc(key);
this.#bucket[index] = new Entry(key, val);
}
/* 删除操作 */
delete(key) {
let index = this.#hashFunc(key);
@ -735,7 +735,7 @@ $$
=== "C"
```c title="array_hash_map.c"
```
=== "C#"
@ -752,7 +752,7 @@ $$
this.val = val;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap
{
@ -804,44 +804,44 @@ $$
class Entry {
var key: Int
var val: String
init(key: Int, val: String) {
self.key = key
self.val = val
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
private var bucket: [Entry?] = []
init() {
// 初始化一个长度为 100 的桶（数组）
for _ in 0 ..< 100 {
bucket.append(nil)
}
}
/* 哈希函数 */
private func hashFunc(key: Int) -> Int {
let index = key % 100
return index
}
/* 查询操作 */
func get(key: Int) -> String? {
let index = hashFunc(key: key)
let pair = bucket[index]
return pair?.val
}
/* 添加操作 */
func put(key: Int, val: String) {
let pair = Entry(key: key, val: val)
let index = hashFunc(key: key)
bucket[index] = pair
}
/* 删除操作 */
func remove(key: Int) {
let index = hashFunc(key: key)
@ -853,13 +853,13 @@ $$
## 哈希冲突
细心的同学可能会发现，**哈希函数 $f(x) = x \% 100$ 会在某些情况下失效**。具体地，当输入的 key 后两位相同时，哈希函数的计算结果也相同，指向同一个 value 。例如，分别查询两个学号 12836 和 20336 ，则有
细心的同学可能会发现，**哈希函数 $f(x) = x \% 100$ 会在某些情况下失效**。具体地，当输入的 key 后两位相同时，哈希函数的计算结果也相同，指向同一个 value 。例如，分别查询两个学号 $12836$ 和 $20336$ ，则有
$$
f(12836) = f(20336) = 36
$$
两个学号指向了同一个姓名，这明显是不对的，我们将这种现象称为「哈希冲突 Hash Collision」，其会严重影响查询的正确性。如何避免哈希冲突的问题将被留在下章讨论。
两个学号指向了同一个姓名，这明显是不对的，我们将这种现象称为「哈希冲突 Hash Collision」。如何避免哈希冲突的问题将被留在下章讨论。
![hash_collision](hash_map.assets/hash_collision.png)

BIN
docs/chapter_tree/binary_search_tree.assets/bst_inorder_traversal.png
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 104 KiB

32
docs/chapter_tree/binary_search_tree.md
Unescape View File

@ -163,7 +163,7 @@ comments: true
=== "C"
```c title="binary_search_tree.c"
```
=== "C#"
@ -286,10 +286,10 @@ comments: true
# 若树为空，直接提前返回
if root is None:
return None
cur = root
pre = None
# 循环查找，越过叶结点后跳出
while cur is not None:
# 找到重复结点，直接返回
@ -302,7 +302,7 @@ comments: true
# 插入位置在 cur 的左子树中
else:
cur = cur.left
# 插入结点 val
node = TreeNode(num)
if pre.val < num:
@ -410,7 +410,7 @@ comments: true
=== "C"
```c title="binary_search_tree.c"
```
=== "C#"
@ -433,7 +433,7 @@ comments: true
// 插入位置在 cur 的左子树中
else cur = cur.left;
}
// 插入结点 val
TreeNode node = new TreeNode(num);
if (pre != null)
@ -519,6 +519,14 @@ comments: true
删除结点操作也使用 $O(\log n)$ 时间，其中查找待删除结点 $O(\log n)$ ，获取中序遍历后继结点 $O(\log n)$ 。
### 排序
我们知道，「中序遍历」遵循“左 $\rightarrow$ 根 $\rightarrow$ 右”的遍历优先级，而二叉搜索树遵循“左子结点 $<$ 根结点 $<$ 右子结点”的大小关系。因此，在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小结点，从而得出一条重要性质：**二叉搜索树的中序遍历序列是升序的**。
借助中序遍历升序的性质，我们在二叉搜索树中获取有序数据仅需 $O(n)$ 时间，而无需额外排序，非常高效。
![bst_inorder_traversal](binary_search_tree.assets/bst_inorder_traversal.png)
=== "Java"
```java title="binary_search_tree.java"
@ -614,10 +622,10 @@ comments: true
# 若树为空，直接提前返回
if root is None:
return None
cur = root
pre = None
# 循环查找，越过叶结点后跳出
while cur is not None:
# 找到待删除结点，跳出循环
@ -628,11 +636,11 @@ comments: true
cur = cur.right
else: # 待删除结点在 cur 的左子树中
cur = cur.left
# 若无待删除结点，则直接返回
if cur is None:
return None
# 子结点数量 = 0 or 1
if cur.left is None or cur.right is None:
# 当子结点数量 = 0 / 1 时， child = null / 该子结点
@ -811,7 +819,7 @@ comments: true
=== "C"
```c title="binary_search_tree.c"
```
=== "C#"
@ -926,7 +934,7 @@ comments: true
}
```
## 二叉搜索树的优势
## 二叉搜索树的效率
假设给定 $n$ 个数字，最常用的存储方式是「数组」，那么对于这串乱序的数字，常见操作的效率为：

5
docs/stylesheets/extra.css
Unescape View File

@ -22,6 +22,11 @@
--md-typeset-a-color: #21C8B8;
}
/* https://github.com/squidfunk/mkdocs-material/issues/4832#issuecomment-1374891676 */
.md-nav__link[for] {
color: var(--md-default-fg-color) !important
}
/* Center Markdown Tables (requires md_in_html extension) */
.center-table {
text-align: center;

Write Preview
Loading…
Cancel
Save