python 哈希表_数据结构-7 哈希表

python内部查找表非常快，就是用的哈希表（hash-table）实现的。

后续实现字典集合。

怎么解决冲突？

其实一种直观的想法是如果冲突了我能不能让数组中对应的槽变成一个链式结构呢？这就是其中一种解决方法，叫做链接法(chaining)。如果我们用链接法来处理冲突：

这样就用链表解决了冲突问题，但是如果哈希函数选不好的话，可能就导致冲突太多一个链变得太长，这样查找就不再是 O(1) 的了。

还有一种叫做开放寻址法(open addressing)，它的基本思想是当一个槽被占用的时候，采用一种方式来寻找下一个可用的槽。（这里槽指的是数组中的一个位置），根据找下一个槽的方式不同，分为：

线性探查(linear probing): 当一个槽被占用，找下一个可用的槽。

h(k, i) =

% m, （i = 0,1,...,m-1 ）

双重散列(double hashing): 重新计算 hash 结果。

h(k,i) =

% m

二次探查(quadratic probing): 当一个槽被占用，以二次方作为偏移量。就是二次哈希。（python使用的就是二次探查。）

% m , i=0,1,...,m-1
#注意：是在第一次得到的index上(+i*i) , 不是每次都累加。

inserted_index_set = set()#建立一个无重复集
M = 13 #键位13def h(key,M = 13):return key % Mto_insert = [765, 431, 96, 142, 579, 226, 903, 388]
#——————————————————————————————————————————————————————————————
for number in to_insert:index = h(number)first_index = index #得到first-index，如果发现这个键位被占用则计算下一个可用的键位。i = 1while index in inserted_index_set: #计算得到下一个可用的槽print('th({number}) = {number} % M = {index} collision' . format(number = number,index = index))index = (first_index + i*i) % M # 根据二次方探查的公式重新计算下一个需要插入的位置i += 1else: #没有被占用就直接输出print('h({number}) = {number} % M = {index}'.format(number = number,index = index))inserted_index_set.add(index)

output：

h(765) = 765 % M = 11
h(431) = 431 % M = 2
h(96) = 96 % M = 5
h(142) = 142 % M = 12
h(579) = 579 % M = 7h(226) = 226 % M = 5 collision
h(226) = 226 % M = 6h(903) = 903 % M = 6 collisionh(903) = 903 % M = 7 collision
h(903) = 903 % M = 10h(388) = 388 % M = 11 collisionh(388) = 388 % M = 12 collisionh(388) = 388 % M = 2 collisionh(388) = 388 % M = 7 collision
h(388) = 388 % M = 1

最终:

装载因子(load factor)

如果继续往我们的哈希表里塞东西会发生什么？空间不够用。这里我们定义一个负载因子的概念(load factor)，其实很简单，就是已经使用的槽数比哈希表大小。比如我们上边的例子插入了 8 个元素，哈希表总大小是 13，它的 load factor 就是 8/13≈0.628/13≈0.62。当我们继续往哈希表插入数据的时候，很快就不够用了。通常当负载因子开始超过 0.8 的时候，就要新开辟空间并且重新进行散列了。

重哈希(Rehashing)

当负载因子超过 0.8 的时候，需要进行 rehashing 操作了。

步骤就是重新开辟一块新的空间，开多大呢？感兴趣的话可以看下 cpython 的 dictobject.c 文件然后搜索 GROWTH_RATE 这个关键字，你会发现不同版本的 cpython 使用了不同的策略。python3.3 的策略是扩大为已经使用的槽数目的两倍。开辟了新空间以后，会把原来哈希表里不为空槽的数据重新插入到新的哈希表里，插入方式和之前一样。这就是 rehashing 操作。

HashTable ADT

实践是检验真理的唯一标准，这里我们来实现一个简化版的哈希表 ADT，主要是为了让你更好地了解它的工作原理，有了它，后边实现起 dict 和 set 来就小菜一碟了。这里我们使用到了定长数组，还记得我们在数组和列表章节里实现的 Array 吧，这里要用上了。

解决冲突我们使用二次探查法，模拟 cpython 二次探查函数的实现。我们来实现三个哈希表最常用的基本操作，这实际上也是使用字典的时候最常用的操作。

add(key, value)
get(key, default)
remove(key)