哈希表
为了快速的定位到某个元素,科学家给每个元素一个“逻辑下标”,然后直接找到元素,哈希表就是这种实现,他通过一个哈希函数来计算一个元素应该放在哪,当然对于特定的某个元素,哈希函数每次计算的下标必须一样才可以,而且范围不能超出给定数组的长度。
假如我们有一个数组t 包含m=13个元素,我们可以定义一个简单的哈喜函数h(key) = key%m 这里取模函数使得h(key)的结果不会超出数组长度的下标,分别插入以下元素 756,431,142,579,226,903,338
哈希冲突:经过hash算法计算,发生了下标的冲突,该下标下的当前值,会有一个链接,指向发生冲突的值(链接法),缺点,如果冲突比较多,查找时就不是O(1)的时间复杂度
还有一种叫 开放寻址法:他的基本思想是当一个槽被占用的时候,采用一种方式来来找到下一个槽,根据找下一槽的方式不同,分为:
线性探查:当槽被占用,找下一个可用的槽
二次探查:当槽被占用,以二次作为偏移量
双重散列:重新计算哈希结果
python使用的是二次探查法,他的意思就是如果遇到冲突,我们就在原始的位置上增加i
平方
装载因子: 已经被使用的槽数比上总槽数
当空间不够用时,我们就定义一个负载因子的概念,比如插入了8个元素,总槽数为13,就是8/13约等于0.62 。通常来说当负载因子小于0.8,就要新开辟空间,并且重新进行散列
冲哈喜
当负载因子小于0.8时,会重新开辟空间,开辟空间的策略要看具体的底层实现,之后把不为空的槽的数据重新哈希到表中
模拟cpython实现一个哈希表
最常用的三个操作,add,get,remove
槽一般有三种状态:
从未被使用:HashMap.UNUSED
使用过但是remove了:HashMap.EMPTY
正在使用的节点
class Array(object):
def __init__(self,size=32,inits=None):
self._size = size
self._items = inits* size
def __getitem__(self,index):
return self._items[index]
def __setitem__(self,index,value):
self._items[index] = value
def __len__(self):
return self._size
def clear(self,value = None):
for i in range(self._items):
self._items[i] = value
def __iter__(self):
for item in self._items:
yield item
#定义一个槽
class Slot(object):
"""
定义一个哈希表数组的槽
注意,一个槽有三种状态,看你能否想明白,相比链接法解决冲突,二次探查法删除一个key更加复杂
1.从未使用 HashMap.UNUSED.次槽没有被使用和冲突过,查找时只要找到UNUSED就不用再继续探查了
2.使用过但是remove了,此时hashMpa.BMPTY,该探查点后边的元素仍可是key
3.槽正在使用Slot点
"""
def __init__(self,key,value):
self.key,self.value = key,value
#实现哈希表
class HashTable(object):
UNUSED = None #没被使用过
BMPTY = Slot(None,None)#使用过但是删除了
#初始化函数
def __init__(self):
#定义一个数组
self._table = Array(8,init = HashTable.UNUSED)
#插入了多少个值
self.length = 0
#装饰器,用于计算装载因子
@property
def _load_factor(self):
return self.length / float(len(self._table))
#hash表的长度
def __len__(self):
return self.lenght
#hsah函数 根据key得到一个数组的下标
def _hash(self,key):
#abs返回绝对值 hash返回key的hash值
return abs(hash(key)) % len(self._table)
#寻找key
def _find_key(self,key):
#调用哈希函数,得到第一个槽的位置
index = self._hash(key)
#hash表的长度
_len = len(self._table)
#表中槽的init值是否为HashMapp.UNUSED
while self._table[index] is not HashTable.UNUSED:
#表中槽的init是否为HashMap.EMPTY
if self._table[index] is HashTable.EMPTY:
#重新计算key
index = (index * 5 + 1) % _len
#跳过出此次循环
continue
#表中有这个key直接输出key
elif self._table[index].key == key:
return index
#否则重新计算key
else:
index = (index * 5 + 1) % _len
#返回None
return None
#判断槽能不能被插入
def _silot_con_insert(self,index):
return (self._table[index] is HashTable.BMPTY or self._table[index] is HashTable.UNUSED)
#找到一个空槽的位置
def _find_slot_for_insert(self,key):
#获取k的哈希值
index = self._hash(key)
#获取到hash表的长度
_len = len(self._table)
#如果不能插入,就重新定义key
while not self._slot_for_insert(index):
index = (index * 5 + 1) % _len
return index
#添加键值对
def add(self,key,value):
if key in self:
#如果有就找到key
index = self._find_key(key)
#把value赋值给槽
self._table[index].value = value
return False
else:
#如果没有找到一个空槽的key
index = self._find_slot_for_insert(key)
#这个空槽指向新的槽
self._table[index] = Slot(key,value)
#长度加一
self.length += 1
#计算装载因子
if self._load_factor >= 0.8:
self._rehash()
return True
#装载因子小于0.8
def _rehash(self):
#把原来的表,赋值给old_table
old_table = self._table
#原来的长度剩2,赋值给newsize
newsize = len(self._table)*2
#新建一个数组
self._table = Array(newsize,HashTable.UNUSED)
self.length = 0
#遍历原来的数组
for slot in old_table:
#判断是否有值
if slot is not HashTable.UNUSED and slot is not HashTable.BMPTY:
#找到新key,赋值给index
index = self._find_slot_for_insert(slot.key)
#slot赋值到槽中
self._table[index] = slot
#长度加一
self.length += 1
#取值操作
def get(self,key,default=None):
#找到这个key
index = self._find_key(key)
#key如果是和None
if index is None:
#返回None
return default
else:
#否则槽中value
return self._table[index].value
#删除操作
def remove(self,key):
#找到key
index = self._find_key(key)
#key为None就抛出异常
if index is None:
raise KeyError()
#取到槽中的value
value = self._table[index].value
#长度减一
self.length -=1
#赋值给key一个状态
self._table[index] = HashTable.BMPTY
#赶回值
return value
#遍历
def __iter__(self):
#循环数组
for slot in self._table:
#判断状态
if slot not in (HashTable.BMPTY,HashTable.UNUSED):
#生成值
yield slot.key