Python拉链法和开地址法实现字典

Python拉链法和开地址法实现字典

Python字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

在列表中使用下标索引可以快速的得到对应的值,那么我们需要做的有两件事情:

  • 怎样把键计算出一个唯一值
  • 怎样把这个唯一值均匀并且唯一的分布在长度固定的列表中

怎样把键计算出一个唯一值

因为字典的键是不可变的,可hash的,因此我们可以用hash函数计算key对应的唯一hash值。

怎样把这个唯一值均匀并且唯一的分布在长度固定的列表中

hash散列是可以把大数据集映射到定长数据集的算法,因此我们可以对上述计算出来的hash值进行散列。很明显散列之后会出现散列冲突。因此我们需要处理这种冲突一遍唯一值能够均匀唯一的分布。这个时候就有两种处理散列冲突的方法:拉链法和开地址法

拉链法

把具有相同散列地址的k,v对放在同一个单链表中。下面实现两个函数

  • put函数:put(slots, key, value),用来向字典中插入数据
  • get函数:get(slots, key),用来从字典中读取数据。

还可以实现更多的函数,比如dict.keys()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#!/usr/bin/env python
# coding=utf-8
slots = []
slotsNum = 32
for _ in range(32):
slots.append([])
def put(slots, key, value):
i = hash(key) % slotsNum
pos = -1
for pos, (k, v) in enumerate(slots[i]):
if key == k:
break
else:
slots[i].append((key, value))
if pos >= 0 and pos < len(slots[i]):
slots[i][pos] = (key, value)
def get(slots, key):
i = hash(key) % slotsNum
for k, v in slots[i]:
if key == k:
return v
else:
raise KeyError(key) # 不存在时抛出异常
put(slots, 'a', 1)
print(get(slots, 'a'))
put(slots, 'b' ,2)
print(get(slots, 'b'))
put(slots, 'a', 3)
print(get(slots, 'a'))

下面将这两个函数封装成类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Dict:
def __init__(self, num):
self.__solts__ = []
self.num = num
for _ in range(num):
self.__solts__.append([])
def put(self, key, value):
i = hash(key) % self.num
for p, (k, v) in enumerate(self.__solts__[i]):
if k == key:
break
else:
self.__solts__[i].append((key, value))
return
self.__solts__[i][p] = (key, value)
def get(self, key):
i = hash(key) % self.num
for k, v in self.__solts__[i]:
if k == key:
return v
raise KeyError(key)
# keys函数
def keys(self):
ret = []
for solt in self.__solts__:
for k, _ in solt:
ret.append(k)
return ret

封装成类之后,使用方法和Python提供的dict就比较像了

开地址法

Python字典内部实现时处理散列冲突的方法就是开地址法,开地址法在后续补充

捐赠:喜欢就请我喝一杯