【漫画算法】哈希表：古代皇帝的秘密魔法书

❤️❤️❤️ 欢迎来到我的博客。希望您能在这里找到既有价值又有趣的内容，和我一起探索、学习和成长。欢迎评论区畅所欲言、享受知识的乐趣！

推荐：数据分析螺丝钉的首页格物致知终身学习期待您的关注

导航：

LeetCode解锁1000题: 打怪升级之旅：每题都包括3-5种算法，以及详细的代码实现，刷题面试跳槽必备
漫画版算法详解：通过漫画的形式和动态GIF图片把复杂的算法每一步进行详细可视解读，看一遍就掌握
python源码解读：解读python的源代码与调用关系，快速提升代码质量
python数据分析可视化：企业实战案例：企业级数据分析案例与可视化，提升数据分析思维和可视化能力
程序员必备的数学知识与应用：全面详细的介绍了工程师都必备的数学知识

期待与您一起探索技术、持续学习、一步步打怪升级欢迎订阅本专栏❤️❤️

引言

在一个神秘的魔法世界里，有一本充满魔力的书，能够快速找到任何被记录的信息。这本书的秘密就在于它使用了一种叫做“哈希表”的魔法算法。本文将通过一个有趣的故事和简洁的漫画，向大家介绍哈希表的基本原理及其实现。

故事背景

在魔法王国中，皇帝拥有一本强大的魔法书，记录着王国里每个居民的信息。每当皇帝需要查找某个居民的信息时，他都能迅速找到。这本魔法书之所以如此强大，是因为它使用了哈希表这一神奇的算法。

角色介绍

皇帝：魔法国王的智慧皇帝，掌握哈希表的秘密。
大臣：国王的得力助手，听从皇帝解释和管理哈希表。
居民：魔法王国的居民，他们的信息被记录在魔法书中。

故事展开

一天，皇帝决定向他的子民们揭示魔法书的秘密。他召集了所有大臣，并开始解释哈希表的原理。
在这里插入图片描述

漫画情节

场景1：国王解释哈希表的基本原理

皇帝展开一卷古老的卷轴，上面刻画着神秘的符号。他对大臣们说道：“这本魔法书之所以能快速找到任何居民的信息，秘密就在于一种叫做哈希表的算法。让我来解释其中的奥秘。”

皇帝继续说道：“首先，每个居民的名字（键）都会通过一个神奇的公式（哈希函数）转换成一个特定的数字（哈希值）。这个数字决定了信息在魔法书中的位置（索引）。例如，当我们插入‘Alice’的电话时，哈希函数会将她的名字转换为数字8，这样她的信息就会存储在索引8的位置。”

“但是，有时候不同的名字可能会被转换成相同的数字，这就是所谓的哈希冲突。比如，当我们插入‘Eve’的电话时，她的名字也被转换成了数字8。为了处理这种冲突，我们会在索引8的位置建立一个链表，将所有冲突的键值对串联起来。”

皇帝用手指着卷轴上的图示：“看，这里是我们目前的哈希表结构。”
插入键值对：居民名字与对应的电话号码。

插入 “Alice” 的电话：12345
插入 “Bob” 的电话：67890
插入 “Charlie” 的电话：54321
插入 “Dave” 的电话：98765
插入 “Eve” 的电话：11111

在这里插入图片描述

场景2：哈希函数的作用

在大殿内，皇帝继续向大臣们讲解哈希表的奥秘，重点介绍了哈希函数的作用。

哈希函数的定义

皇帝展开手中的卷轴，上面描绘着一个复杂而神秘的公式。他说道：“哈希函数是哈希表的核心，它的作用是将输入的键（比如居民的名字）转换成一个固定范围内的整数（哈希值）。这个整数决定了键值对在哈希表中的存储位置。”

哈希函数的作用

将键映射到索引：
皇帝用手指着卷轴上的公式，解释道：“通过哈希函数，我们可以将每个键映射到一个特定的索引位置。比如，名字‘Alice’通过哈希函数计算得到哈希值‘8’，所以她的信息将存储在索引‘8’的位置。”
均匀分布键值对：
皇帝继续说道：“哈希函数的设计目的是尽可能均匀地分布键值对在哈希表中，避免出现太多的哈希冲突。这有助于提高查找和插入操作的效率。”
快速查找：
“当我们需要查找某个键对应的值时，比如查找‘Charlie’的电话，只需通过哈希函数计算出哈希值‘6’，然后直接访问索引‘6’的位置，就能快速找到他的电话号码‘54321’。”
处理哈希冲突：
皇帝解释道：“尽管哈希函数的设计尽量避免冲突，但在某些情况下，不同的键可能会映射到相同的索引位置，这就是哈希冲突。比如，‘Alice’和‘Eve’都映射到索引‘8’。我们可以通过链表法将这些冲突的键值对存储在同一个索引位置的链表中。”

示例

皇帝举了一个例子来说明哈希函数的作用：

大臣们根据皇帝的指示，开始往魔法书（哈希表）中插入居民的信息。

插入 Alice 的电话：12345

哈希值 = (A:65 + l:108 + i:105 + c:99 + e:101) % 10 = 478 % 10 = 8
将 Alice 和她的电话号码插入到索引 8 的位置。

插入 Bob 的电话：67890

哈希值 = (B:66 + o:111 + b:98) % 10 = 275 % 10 = 5
将 Bob 和他的电话号码插入到索引 5 的位置。

插入 Charlie 的电话：54321

哈希值 = (C:67 + h:104 + a:97 + r:114 + l:108 + i:105 + e:101) % 10 = 696 % 10 = 6
将 Charlie 和他的电话号码插入到索引 6 的位置。

插入 Dave 的电话：98765

哈希值 = (D:68 + a:97 + v:118 + e:101) % 10 = 384 % 10 = 4
将 Dave 和他的电话号码插入到索引 4 的位置。

插入 Eve 的电话：11111

哈希值 = (E:69 + v:118 + e:101) % 10 = 288 % 10 = 8
发现索引 8 已经被 Alice 占用，发生哈希冲突。使用链表法将 Eve 添加到索引 8 的链表中。

皇帝总结道：“哈希函数的主要作用是将键转换成固定范围内的整数，从而确定键值对在哈希表中的存储位置。通过合理设计哈希函数，我们可以有效地分配存储空间，提高查找和插入操作的效率，并处理哈希冲突。”

大臣们听完后纷纷点头称赞，深刻理解了哈希函数在哈希表中的重要作用和工作原理。

场景3：处理哈希冲突

皇帝继续说道：“哈希表虽然高效，但有时会遇到哈希冲突。今天，我将讲解如何处理这些冲突。”

哈希冲突的产生

当不同的键映射到相同的索引时，就会发生哈希冲突。例如：

Alice：哈希值 8
Eve：哈希值 8

解决哈希冲突的方法

皇帝解释了几种常用的方法来处理哈希冲突：

链地址法（Separate Chaining）：

在每个索引位置维护一个链表，将冲突的键值对存储在链表中。
优点：实现简单，冲突处理灵活。
缺点：需要额外的存储空间来维护链表。

示例：

Index  |  Key                |  Value
------------------------------------
  0    |                     |       
  1    |                     |       
  2    |                     |       
  3    |                     |       
  4    | Dave                |  98765
  5    | Bob                 |  67890
  6    | Charlie             |  54321
  7    |                     |       
  8    | Alice -> Eve        | 12345 -> 11111
  9    |                     |

开放地址法（Open Addressing）：
- 当发生冲突时，寻找下一个空闲的位置来存储键值对。
- 优点：不需要额外的存储空间。
- 缺点：查找和插入的时间复杂度可能增加。
常用的开放地址法包括：
- 线性探测（Linear Probing）：按顺序查找下一个空闲位置。
- 二次探测（Quadratic Probing）：按平方序列查找空闲位置。
- 双重哈希（Double Hashing）：使用第二个哈希函数查找空闲位置。

通过这些方法，哈希表可以有效地处理哈希冲突，确保数据能够正确存储和快速查找。

哈希表的实现

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.next = None

class HashTable:
    def __init__(self):
        self.size = 10
        self.table = [None] * self.size

    def hash_function(self, key):
        return sum(ord(char) for char in key) % self.size

    def insert(self, key, value):
        index = self.hash_function(key)
        new_node = Node(key, value)
        if self.table[index] is None:
            self.table[index] = new_node
        else:
            current = self.table[index]
            while current.next:
                if current.key == key:
                    current.value = value
                    return
                current = current.next
            if current.key == key:
                current.value = value
            else:
                current.next = new_node

    def search(self, key):
        index = self.hash_function(key)
        current = self.table[index]
        while current:
            if current.key == key:
                return current.value
            current = current.next
        return None

# 使用示例
hash_table = HashTable()
hash_table.insert("Alice", 12345)
hash_table.insert("Bob", 67890)
hash_table.insert("Charlie", 54321)
hash_table.insert("Dave", 98765)
hash_table.insert("Eve", 11111)

print("查找 'Alice' 的电话:", hash_table.search("Alice"))  # 输出: 12345
print("查找 'Eve' 的电话:", hash_table.search("Eve"))    # 输出: 11111

查找操作

查找 Alice 的电话号码

计算哈希值：hash_function(“Alice”) = 8
在索引 8 查找键值对：

发现 Alice 的键，返回电话号码 12345。
查找 Eve 的电话号码

计算哈希值：hash_function(“Eve”) = 8
在索引 8 查找键值对：

发现 Alice 的键，不匹配，继续下一个节点。
发现 Eve 的键，匹配，返回电话号码 11111。

哈希表的优点

快速查找：通过哈希函数，能够快速定位信息的位置。
灵活存储：适用于各种类型的数据存储和查找。
高效管理：在处理大量数据时，哈希表能够保持高效的性能。

以下是哈希表、数组和链表的优缺点及时间复杂度的比较表格：

数据结构	优点	缺点	查找时间复杂度	插入时间复杂度	删除时间复杂度
哈希表	- 平均情况下查找、插入和删除操作非常快，时间复杂度为 O(1) - 动态扩展，适合处理大量数据 - 不需要有序	- 可能会发生哈希冲突，最坏情况下查找、插入和删除的时间复杂度为 O(n) - 需要额外的空间来存储哈希函数和链表 - 适用于等值查找，不适用于区间查找	平均 O(1) 最坏 O(n)	平均 O(1) 最坏 O(n)	平均 O(1) 最坏 O(n)
数组	- 支持快速随机访问，时间复杂度为 O(1) - 存储结构简单，内存连续	- 插入和删除操作效率低，需要移动大量数据，时间复杂度为 O(n) - 固定大小，动态调整需要重新分配内存	O(1)	O(n)	O(n)
链表	- 动态大小，可以高效地进行插入和删除操作，时间复杂度为 O(1) - 内存利用率高，不需要预分配空间	- 不支持高效的随机访问，查找时间复杂度为 O(n) - 需要额外的内存存储指针，导致空间开销较大	O(n)	O(1)	O(1)