Python 散列表查询_进入<哈希函数>为结界的世界

2022年05月12日 阅读数:3
这篇文章主要向大家介绍Python 散列表查询_进入<哈希函数>为结界的世界,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

1. 前言

哈希表或称为散列表,是一种常见的、使用频率很是高的数据存储方案。node

哈希表属于抽象数据结构,须要开发者按哈希表数据结构的存储要求进行 API 定制,对于大部分高级语言而言,都会提供已经实现好的、可直接使用的 API,如 JAVA 中有 MAP 集合、C++ 中的 MAP 容器,Python 中的字典……python

使用者可使用 API 中的方法完成对哈希表的增、删、改、查……一系列操做。算法

如何学习哈希表?数组

能够从 2 个角度开始:markdown

  • 使用者角度:只须要知道哈希表是基于对存储的解决方案,另须要熟悉不一样计算机语言提供的基于哈希表数据结构的 API实现,学会使用 API中的方法。
  • 开发者的角度:则须要知道哈希表底层实现原理,以及实现过程当中须要解决的各类问题。本文将站在开发者的角度,带着你们一块儿探究哈希的世界。

2. 哈希表

什么是哈希表?数据结构

哈希表是基于对存储的数据结构,底层通常采用的是列表(数组)ide

你们都知道,基于列表(数组)的查询速度很是快,时间复杂度是 O(1),常量级别的。函数

列表的底层存储结构是连续的内存区域,只要给定数据在列表(数组)中的位置,就能直接查询到数据。理论上是这么回事,但在实际操做过程,查询数据的时间复杂度却不必定是常量级别的。性能

如存储下面的学生信息,学生信息包括学生的姓名和学号。在存储学生数据时,若是把学号为 0 的学生存储在列表 0 位置,学号为 1 的学生存储在列表 1 位置……学习

hx01.png

这里把学生的学号和列表的索引号进行关联,查询某一个学生时,知道了学生的学号也就知道了学生数据存储在列表中的位置,能够认为查询的时间复杂度为 O(1)

之因此能够达到常量级,是由于这里有信息关联(学生学号关联到数据的存储位置)。

还有一点,学生的学号是公开信息也是经常使用信息,很容易获取。

可是,不是存储任何数据时,均可以找到与列表位置相关联的信息。好比存储全部的英文单词,不可能为每个英文单词编号,即便编号了,编号在这里也仅仅是流水号,没有数据含义的数据对于使用者来说是不友好,谁也没法记住哪一个英文单词对应哪一个编号。

因此使用列表存储英文单词后须要询时,因没有单词的存储位置。仍是须要使用如线性二分……之类的查询算法,这时的时间复杂度由使用的查询算法的时间复杂度决定。

若是对上述存储在列表的学生信息进行了插入删除……等操做,改变了数据原来的位置后,因破坏了学号与位置关联信息,再查询时也只能使用其它查询算法,不可能达到常量级。

是否存在一种方案,能最大化地优化数据的存储和查询?

经过上述的分析,能够得出一个结论,要提升查询的速度,得想办法把数据位置进行关联。而哈希表的核心思想即是如此。

2.1 哈希函数

哈希表引入了关键字概念,关键字能够认为是数据的别名。如上表,能够给每个学生起一个别名,这个就是关键字

hx02.png

Tip: 这里的关键字是姓名的拼音缩写,关键字数据的关联性较强,方便记忆和查询。

有了关键字后,再把关键字映射成列表中的一个有效位置,映射方法就是哈希表中最重要的概念哈希函数

关键字是一个桥梁,即关联到真正数据又关联到哈希表中的位置。

关键字也能够是须要保存的数据自己。

哈希函数的功能:提供把关键字映射到列表中的位置算法,是哈希表存储数据的核心所在。以下图,演示数据哈希函数哈希表之间的关系,能够说哈希函数是数据进入哈希表的入口。

hx03.png

数据最终会存储在列表中的哪个位置,彻底由哈希算法决定。

当须要查询学生数据时,一样须要调用哈希函数关键字进行换算,计算出数据在列表中的位置后就能很容易查询到数据。

若是忽视哈希函数的时间复杂度,基于哈希表的数据存储和查询时间复杂度是 O(1)

如此说来哈希函数算法设计的优劣是影响哈希表性能的关键所在。

2.2 哈希算法

哈希算法决定了数据的最终存储位置,不一样的哈希算法设计方案,也关乎哈希表的总体性能,因此,哈希算法就变得的尤其重要。

下文将介绍并纵横比较几种常见的 哈希算法的设计方案。

Tip: 不管使用何种哈希算法,都有一个根本,哈希后的结果必定是一个数字,表示列表(哈希表)中的一个有效位置。也称为哈希值

使用哈希表存储数据时,关键字能够是数字类型也能够是非数字类型,其实,关键字能够是任何一种类型。这里先讨论当关键字为非数字类型时设计哈希算法的基本思路。

如前所述,已经为每个学生提供了一个以姓名的拼音缩写的关键字

如今如何把关键字映射到列表的一个有效位置?

这里能够简单地把拼音当作英文中的字母,先分别计算每个字母在字母表中的位置,而后相加,获得的一个数字。

使用上面的哈希思想对每个学生的关键字进行哈希:

  • zjl的哈希值为 26+10+12=48
  • llj的哈希值为 12+12+10=34
  • cl 的哈希值为 3+12=15
  • zxy的哈希值为 26+25+24=75

前文说过哈希值是表示数据在列表中的存储位置,如今假设一种理想化状态,学生的姓名都是 3 个汉字,意味着关键字也是 3 个字母,采用上面的的哈希算法,最大的哈希值应该是zzz=26+26+26=78,意味着至少应该提供一个长度为 78的列表 。

若是,如今仅仅只保存 4 名学生,虽然只有 4 名学生,因没法保证学生的关键字不出现zzz,因此列表长度仍是须要 78。以下图所示。

hx04.png

采用这种哈希算法会致使列表的空间浪费严重,最直观想法是对哈希值再作约束,如除以 4 再取余数,把哈希值限制在 4 以内,4 个数据对应 4 个哈希值。咱们称这种取余数方案为取余数算法

取余数法中,被除数通常选择小于哈希表长度的素数。本文介绍其它哈希算法时,也会使用取余数法对哈希值进行适当范围的收缩。

从新对 4 名学生的关键字进行哈希。

  • zjl的哈希值为 26+10+12=4848 除以 4 取余数,结果是0
  • llj的哈希值为 12+12+10=3434 除以 4 取余数,结果是2
  • cl 的哈希值为 3+12=1515 除以 4 取余数,结果是3
  • zzz的哈希值为 26+26+26=7878 除以 4 取余数,结果是2

hx05.png

演示图上出现了一个很奇怪的现象,没有看到李连杰的存储信息。

4个存储位置存储 4学生,应该是刚恰好,可是,只存储了 3名学生。且还有 1个位置是空闲的。如今编码验证一下,看是否是人为因素引发的。

'''
哈希函数
'''
def hash_code(key):
    # 设置字母 A 的在字母表中的位置是 1
    pos = 0
    for i in key:
        i = i.lower()
        res = ord(i) - ord('a') + 1
        pos += res
    return pos % 4

测试代码:

# 哈希表
hash_table = [None] * 4
# 计算关键字的哈希值
idx = hash_code('zjl')
# 根据关键字换算出来的位置存储数据
hash_table[idx] = '周杰伦'
idx = hash_code('llj')
hash_table[idx] = '李连杰'
idx = hash_code('cl')
hash_table[idx] = '成龙'
idx = hash_code('zzz')
hash_table[idx] = '张志忠'
print('哈希表中的数据:', hash_table)
'''
输出结果:
哈希表中的数据: ['周杰伦', None, '张志忠', '成龙']
'''

执行代码,输出结果,依然仍是没有看到李连杰的信息。

缘由何在?

这是由于李连杰张志忠的哈希值都是 2 ,致使在存储时,后面存储的数据会覆盖前面存储的数据,这就是哈希中的典型问题,哈希冲突问题

所谓哈希冲突,指不一样的关键字在进行哈希算法后获得相同的哈希值,这意味着,不一样关键字所对应的数据会存储在同一个位置,这确定会发生数据丢失,因此须要提供算法,解决冲突问题。

Tip: 研究哈希表,归根结底,是研究如何计算哈希值以及如何解决哈希值冲突的问题。

针对上面的问题,有一种想固然的冲突解决方案,扩展列表的存储长度,如把列表扩展到长度为 8

直观思惟是:扩展列表长度,哈希值的范围会增长,冲突的可能性会下降。

'''
哈希函数
'''
def hash_code(key):
    # 设置字母 A 的在字母表中的位置是 1
    pos = 0
    for i in key:
        i = i.lower()
        res = ord(i) - ord('a') + 1
        pos += res
    return pos % 8

# 哈希表
hash_table = [None] * 8

# 保存全部学生
idx = hash_code('zjl')
hash_table[idx] = '周杰伦'
idx = hash_code('llj')
hash_table[idx] = '李连杰'
idx = hash_code('cl')
hash_table[idx] = '成龙'
idx = hash_code('zzz')
hash_table[idx] = '张志忠'
print('哈希表中的数据:', hash_table)
'''
输出结果:
哈希表中的数据: ['周杰伦', None, '李连杰', None, None, None, '张志忠', '成龙']
'''

hx06.png

貌似解决了冲突问题,其实否则,当试着设置列表的长度为678910时,只有当长度为 8时没有发生冲突,这仍是在要存储的数据是已知状况下的尝试。

若是数据是动态变化的,显然这种扩展长度的方案绝对不是本质解决冲突的方案。即不能解决冲突,且产生大量空间浪费。

如何解决哈希冲突,会在后文详细介绍,这里仍是回到哈希算法上。

综上所述,咱们对哈希算法的理想要求是:

  • 为每个关键字生成一个惟一的哈希值,保证每个数据都有只属于本身的存储位置。
  • 哈希算法的性能时间复杂度要低。

现实状况是,同时知足这 2 个条件的哈希算法几乎是不可能有的,面对数据量较多时,哈希冲突是常态。因此,只能是尽量知足。

因冲突的存在,即便为 100 个数据提供 100 个有效存储空间,仍是会有空间闲置。这里把实际使用空间和列表提供的有效空间相除,获得的结果,称之为哈希表的占有率(载荷因子)

如上述,当列表长度为 4时, 占有率为 3/4=0.75,当列表长度为 8 时,占有率为 4/8=0.5,通常要求占率控制 在0.6~0.9之间。

2.3 常见哈希算法

前面在介绍什么是哈希算法时,提到了取余数法,除此以外,还有几种常见的哈希算法

2.3.1 折叠法

折叠法:关键字分割成位数相同的几个部分(最后一部分的位数能够不一样)而后取这几部分的叠加和(舍去进位)做为哈希值。

折叠法又分移位叠加和间界叠加。

  • 移位叠加:将分割后的每一部分的最低位对齐,而后相加。

  • 间界叠加:从一端沿分割线来回折叠,而后对齐相加。

因有相加求和计算,折叠法适合数字类型或能转换成数字类型的关键字。假设如今有不少商品订单信息,为了简化问题,订单只包括订单编号和订单金额。

如今使用用哈希表存储订单数据,且以订单编号为关键字,订单金额为

订单编号 订单金额
20201011 400.00
19981112 300.00
20221212 200

移位叠法换算关键字的思路:

第一步:把订单编号 20201011 按每3位一组分割,分割后的结果:20二、0十、11

2 位一组仍是 3 位一组进行分割,能够根据实际状况决定。

第二步: 把分割后的数字相加 202+010+11,获得结果:223。再使用取余数法,若是哈希表的长度为 10,则除以 10后的余数为3

这里除以 10 仅是为了简化问题细节,具体操做时,不多选择列表的长度。

第三步:对其它的关键字采用相同的处理方案。

关键字 哈希值
20201011 3
19981112 2
20221212 6

编码实现保存商品订单信息:

'''
移位叠加哈希算法
'''
def hash_code(key, hash_table_size):
    # 转换成字符串
    key_s = str(key)
    # 保存求和结果
    s = 0
    # 使用切片
    for i in range(0, len(key_s), 3):
        s += int(key_s[i:i + 3])
    return s % hash_table_size

# 商品信息
products = [[20201011, 400.00], [19981112, 300], [20221212, 200]]
# 哈希表长度
hash_size = 10
# 哈希表
hash_table = [None] * hash_size
# 以哈希表方式进行存储
for p in products:
    key = hash_code(p[0], hash_size)
    hash_table[key] = p[1]
# 显示哈希表中的数据
print("哈希表中的数据:",hash_table)
# 根据订单号进行查询
hash_val = hash_code(19981112, hash_size)
val = hash_table[hash_val]
print("订单号为{0}的金额为{1}".format(19981112, val))
'''
输出结果
哈希表中的数据: [None, None, 300, 400.0, None, None, 200, None, None, None]
订单号为19981112的金额为300
'''

间界叠加法:

间界叠加法,会间隔地把要相加的数字进行反转。

如订单编号 199811123位一组分割,分割后的结果:19九、8十一、12,间界叠加操做求和表达式为 199+118+12=339,再把结果 339 % 10=9

编码实现间界叠加算法:

'''
间界叠加哈希算法
'''
def hash_code(key, hash_table_size):
    # 转换成字符串
    key_s = str(key)
    # 保存求和结果
    s = 0
    # 使用切片
    for i in range(0, len(key_s), 3):
        # 切片
        tmp_s = key_s[i:i + 3]
        # 反转
        if i % 2 != 0:
            tmp_s = tmp_s[::-1]
        s += int(tmp_s)
    return s % hash_table_size

# 商品信息(数据样例)
products = [[20201011, 400.00], [19981112, 300], [20221212, 200]]
# 哈希表长度
hash_size = 10
# 哈希表
hash_table = [None] * hash_size
# 以哈希表方式进行存储
for p in products:
    key = hash_code(p[0], hash_size)
    hash_table[key] = p[1]
# 显示哈希表中的数据
print("哈希表中的数据:", hash_table)
# 根据订单号进行查询
hash_val = hash_code(19981112, hash_size)
val = hash_table[hash_val]
print("订单号为{0}的金额为{1}".format(19981112, val))
'''
输出结果:
哈希表中的数据: [None, None, None, 400.0, None, None, 200, None, None, 300]
订单号为19981112的金额为300
'''

2.3.2 平方取中法

平方取中法:先是对关键字求平方,再在结果中取中间位置的数字。

求平方再取中算法,是一种较常见的哈希算法,从数学公式可知,求平方后获得的中间几位数字与关键字的每一位都有关,取中法能让最后计算出来的哈希值更均匀。

因要对关键字求平方,关键字只能是数字或能转换成数字的类型,至于关键字自己的大小范围限制,要根据使用的计算机语言灵活设置。

以下面的图书数据,图书包括图书编号和图书名称。如今须要使用哈希表保存图书信息,以图书编号为关键字,图书名称为值。

图书编号 图书名称
58 python 从入门到精通
67 C++ STL
78 Java 内存模型

使用平方取中法计算关键字的哈希值:

第一步:对图书编号 58 求平方,结果为 3364

第二步:取 3364的中间值36,而后再使用取余数方案。若是哈希表的长度为 10,则 36%10=6

第三步:对其它的关键字采用相同的计算方案。

编码实现平方取中算法:

'''
哈希算法
平方取中
'''
def hash_code(key, hash_table_size):
    # 求平方
    res = key ** 2
    #  取中间值,这里取中间 2 位(简化问题)
    res = int(str(res)[1:3])
    # 取余数
    return res % hash_table_size

hash_table_size = 10
hash_table = [None]*hash_table_size
# 图书信息
books = [[58, "python 从入门到精通"], [67, "C++ STL"], [78, "Java 内存模型"]]
for b in books:
    hash_val = hash_code(b[0],hash_table_size)
    hash_table[hash_val]=b[1]

# 显示哈希表中的数据
print("哈希表中的数据:", hash_table)
# 根据编号进行查询
hash_val = hash_code(67, hash_table_size)
val = hash_table[hash_val]
print("编号为{0}的书名为{1}".format(67, val))

上述求平方取中间值的算法仅针对于本文提供的图书数据,若是须要算法具备通用性,则须要根据实际状况修改。

不要被 取中字所迷惑,不必定是绝对中间位置的数字。

2.3.3 直接地址法

直接地址法:提供一个与关键字相关联的线性函数。如针对上述图书数据,能够提供线性函数 f(k)=2*key+10

系数2和常数10的选择会影响最终生成的哈希值的大小。能够根据哈希表的大小和操做的数据含义自行选择。

key 为图书编号。当关键字不相同时,使用线性函数获得的值也是惟一的,因此,不会产生哈希冲突,可是会要求哈希表的存储长度比实际数据要大。

这种算法在实际应用中并很少见。

实际应用时,具体选择何种哈希算法,彻底由开发者定夺,哈希算法的选择没有固定模式可循,虽然上面介绍了几种算法,只是提供一种算法思路。

2.4 哈希冲突

哈希冲突是怎么引发的,前文已经说过。如今聊聊常见的几种哈希冲突解决方案。

2.4.1 线性探测

当发生哈希冲突后,会在冲突位置以后寻找一个可用的空位置。以下图所示,使用取余数哈希算法,保存数据到哈希表中。

哈希表的长度设置为 15,除数设置为 13

hx07.png

解决冲突的流程:

  1. 7826的哈希值都是 0。而由于7826的前面,78先占据哈希表的 0位置。

  2. 当存储 26时,只能以 0位置为起始位置,向后寻找空位置,因 1位置没有被其它数据占据,最终保存在哈希表的1位置。

  3. 当存储数字 14时,经过哈希算法计算,其哈希值是1,本应该要保存在哈希表中1的位置,因1位置已经被26所占据,只能向后寻找空位置,最终落脚在2位置。

线性探测法让发生哈希冲突的数据保存在其它数据的哈希位置,若是冲突的数据较多,则占据的本应该属于其它数据的哈希位置也较多,这种现象称为哈希汇集

查询流程:

以查询数据14为例。

  1. 计算 14的哈希值,获得值为 1 ,根据哈希值在哈希表中找到对应位置。
  2. 查看对应位置是否存在数据,若是不存在,宣告查询失败,若是存在,则须要提供数据比较方法。
  3. 1位置的数据 26并不等于14。因而,继续向后搜索,并逐一比较。
  4. 最终能够获得结论14在哈希表的编号为2的位置。

因此,在查询过程当中,除了要提供哈希函数,还须要提供数据比较函数。

删除流程:

以删除数字26为例。

  1. 按上述的查询流程找到数字26在哈希表中的位置1

  2. 设置位置1为删除状态,必定要标注此位置曾经保存过数据,而不能设置为空状态。为何?

    若是设置为空状态,则在查询数字14时,会产生错误的返回结果,会认为 14不存在。为何?本身想一想。

编码实现线性探测法:

添加数据:

'''
线性探测法解决哈希冲突
'''
def hash_code(key, hash_table, num):
    # 哈希表的长度
    size = len(hash_table)
    # 取余数法计算哈希值
    hash_val = key % num
    # 检查此位置是否已经保存其它数据
    if hash_table[hash_val] is not None:
        # 则从hash_val 以后寻找空位置
        for i in range(hash_val + 1, size + hash_val):
            if i >= size:
                i = i % size
            if hash_table[i] is None:
                hash_val = i
                break
    return hash_val

# 哈希表
hash_table = [None] * 15
src_nums = [25, 78, 56, 32, 88, 26, 73, 81, 14]
for n in src_nums:
    hash_val = hash_code(n, hash_table, 13)
    hash_table[hash_val] = n

print("哈希表中的数据:", hash_table)
'''
输出结果:
哈希表中的数据: [78, 26, 14, 81, 56, None, 32, None, 73, None, 88, None, 25, None, None]
'''

Tip:为了保证当哈希值发生冲突后,若是从冲突位置查到哈希表的结束位置仍是没有找到空位置,则再从哈希表的起始位置,也就是 0 位置再搜索到冲突位置。冲突位置是起点也是终点,构建一个查找逻辑环,以保证必定能找到空位置。

for i in range(hash_val + 1, size + hash_val):
   pass

基于线性探测的数据查询过程和存储过程大体相同:

def get(key, hash_table, num):
    # 哈希表的长度
    size = len(hash_table)
    # 取余数法计算哈希值
    hash_val = key % num
    is_exist = False
    # 检查此位置是否已经保存其它数据
    if hash_table[hash_val] is None:
        # 不存在
        return None
    if hash_table[hash_val] != key:
        # 则从hash_val 以后寻找空位置
        for i in range(hash_val + 1, size + hash_val):
            if i >= size:
                i = i % size
            if hash_table[i] == key:
                hash_val = i
                is_exist = True
                break
    else:
        is_exist=True
    if is_exist:
        return hash_val

# 测试   
res = get(25, hash_table, 13)
print(res)

为了减小数据汇集,能够采用增量线性探测法,所谓增量指当发生哈希冲突后,探测空位置时,使用步长值大于 1的方式跳跃式向前查找。目的是让数据分布均匀,减少数据汇集。

除了采用增量探测以外,还可使用再哈希的方案。也就是提供2 个哈希函数,第 1 次哈希值发生冲突后,再调用第 2 个哈希函数再哈希,直到冲突再也不产生。这种方案会增长计算时间。

2.4.4 链表法

上面所述的冲突解决方案的核心思想是,当冲突发生后,在哈希表中再查找一个有效空位置。

这种方案的优点是不会产生额外的存储空间,但易产生数据汇集,会让数据的存储不均衡,而且会违背初衷,经过关键字计算出来的哈希值并不能准确描述数据正确位置。

链表法应该是全部解决哈希冲突中较完美的方案。所谓链表法,指当发生哈希冲突后,以冲突位置为首结点构建一条链表,以链表方式保存全部发生冲突的数据。以下图所示:

hx08.png

链表方案解决冲突,不管在存储、查询、删除时都不会影响其它数据位置的独立性惟一性,且因链表的操做速度较快,对于哈希表的总体性能都有较好改善。

使用链表法时,哈希表中保存的是链表的首结点。首结点能够保存数据也能够不保存数据。

编码实现链表法:链表实现须要定义 2 个类,1 个是结点类,1 个是哈希类。

'''
结点类
'''
class HashNode():
    def __init__(self, value):
        self.value = value
        self.next_node = None

'''
哈希类
'''
class HashTable():
    def __init__(self):
        # 哈希表,初始大小为 15,能够根据须要动态修改
        self.table = [None] * 15
        # 实际数据大小
        self.size = 0

    '''
    存储数据
    key:关键字
    value:值
    '''

    def put(self, key, value):
        hash_val = self.hash_code(key)
        # 新结点
        new_node = HashNode(value)
        if self.table[hash_val] is None:
            # 本代码采用首结点保存数据方案
            self.table[hash_val] = new_node
            self.size+=1
        else:
            move = self.table[hash_val]
            while move.next_node is not None:
                move = move.next_node
            move.next_node = new_node
            self.size+=1

    '''
    查询数据
    '''
    def get(self, key):
        hash_val = self.hash_code(key)
        if self.table[hash_val] is None:
            # 数据不存在
            return -1

        if self.table[hash_val].value == key:
            # 首结点就是要找的数据
            return self.table[hash_val].value

        # 移动指针
        move = self.table[hash_val].next_node
        while move.value != key and move is not None:
            move = move.next_node
        if move is None:
            return -1
        else:
            return move.value

    def hash_code(self, key):
        # 这里仅为说明问题,13 的选择是固定的
        hash_val = key % 13
        return hash_val

# 原始数据
src_nums = [25, 78, 56, 32, 88, 26, 39, 82, 14]
# 哈希对象
hash_table = HashTable()
# 把数据添加到哈希表中
for n in src_nums:
    hash_table.put(n, n)
# 输出哈希表中的首结点数据
for i in hash_table.table:
    if i is not None:
        print(i.value,end=" ")
print("\n-------------查询-----------")
print(hash_table.get(26))
'''
输出结果:
78 14 56 32 88 25 
-------------查询-----------
26
'''

3.总结

哈希表是一种高级数据结构,其存储、查询性能很是好,在不考虑哈希哈希算法和哈希冲突的时间复杂度状况下,哈希查找时间复杂度能够达到常量级,成为不少实际应用场景下的首选。

研究哈希表,着重点就是搞清楚哈希算法以及如何解决哈希冲突。在算法的世界时,没有固定的模式,开发者能够根据本身的须要自行设计哈希算法。