Title

Python实现哈希表

哈希表：

有一个数组的长度为M，key是要保存的键，h是一个哈希函数
通过%取模使得下标不会超过数组长度
h(key) = key % M

M = 9
h(256) = 256 % M = 4
h(313) = 313 % M = 7
h(45) = 45 % M = 0
h(421) = 421 % M = 7
h(137) = 137 % M = 2     冲突

哈希冲突：
不同的key经过h函数计算后得到的下标一样，称为哈希冲突
1.链接法(chaining) 数组中对应的槽变成一个链式结构
2.线性探查(linear probing): 当一个槽被占用，找下一个可用的槽。
h(k,i)=(h′(k)+i)%m,i=0,1,...,m−1h(k,i)=(h′(k)+i)%m,i=0,1,...,m−1
3.二次探查(quadratic probing): 当一个槽被占用，以二次方作为偏移量。
h(k,i)=(h′(k)+c1+c2i2)%m,i=0,1,...,m−1h(k,i)=(h′(k)+c1+c2i2)%m,i=0,1,...,m−1
4.双重散列(double hashing): 重新计算 hash 结果。
h(k,i)=(h1(k)+ih2(k))%mh(k,i)=(h1(k)+ih2(k))%m

inserted_index_set = set()
M = 9

def h(key, M=9):
    return key % M

to_insert = [256, 313, 45, 421, 317]
for number in to_insert:
    index = h(number)
    first_index = index
    i = 1
    while index in inserted_index_set:   # 如果计算发现已经占用，继续计算得到下一个可用槽的位置
        print('	h({number}) = {number} % M = {index} collision'.format(number=number, index=index))
        index = (first_index +  i*i) % M   # 根据二次方探查的公式重新计算下一个需要插入的位置
        i += 1
    else:
        print('h({number}) = {number} % M = {index}'.format(number=number, index=index))
        inserted_index_set.add(index)

装载因子：已经使用的槽数/哈希表大小
5/9 = 0.56
当装载因子超过 0.8 时，就要开辟空间重新进行散列，俗称重哈希

class Array(object):
    def __init__(self, size=32, init=None):
        self._size = size
        self._items = [init] * self._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(len(self._items)):
            self._items[i] = value

    def __iter__(self):
        for item in self._items:
            yield item


class Slot(object):
    """定义一个 hash 表 数组的槽
    注意，一个槽有三种状态，看你能否想明白
    1.从未使用 HashMap.UNUSED。此槽没有被使用和冲突过，查找时只要找到 UNUSED 就不用再继续探查了
    2.使用过但是 remove 了，此时是 HashMap.EMPTY，该探查点后边的元素扔可能是有key
    3.槽正在使用 Slot 节点
    """
    def __init__(self, key, value):
        self.key, self.value = key, value


class HashTable(object):
    # 表示从未被使用过
    UNUSED = None
    # 使用过，但是被删除了
    EMPTY = 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))

    def __len__(self):
        return self.length

    # 哈希函数 用内置的哈希哈数进行哈希一下，然后对数组长度取模
    def _hash(self, key):
        return abs(hash(key)) % len(self._table)

    def _find_key(self, key):
        # 得到第一个值的位置
        index = self._hash(key)
        _len = len(self._table)
        # 当这个槽不是未使用过的，才接着往下找；如果是未使用过的，这个key肯定不存在
        while self._table[index] is not HashTable.UNUSED:
            # 槽使用过，但是被删除了
            if self._table[index] is HashTable.EMPTY:
                # cpython解决哈希冲突的一种方式
                index = (index*5 + 1) % _len
                continue
            elif self._table[index] == key:
                return index
            else:
                index = (index * 5 + 1) % _len
        return None

    # 检测槽是否能被插入
    def _slot_can_insert(self, index):
        return (self._table[index] is HashTable.EMPTY or self._table[index] is HashTable.UNUSED)

    # 找到能被插入的槽的index
    def _find_slot_insert(self, key):
        # 得到第一个值的位置
        index = self._hash(key)
        _len = len(self._table)
        while not self._slot_can_insert(index):
            index = (index * 5 + 1) % _len
        return index

    # 重写 in 操作符
    def __contains__(self, key):
        index = self._find_key(key)
        return index is not None

    def add(self, key, value):
        if key in self:
            index = self._find_key(key)
            # 更新值
            self._table[index].value = value
            return False
        else:
            index = self._find_slot_insert(key)
            self._table[index] = Slot(key, value)
            self.length += 1
            if self._load_factor > 0.8:
                return self._rehash()
            return True

    def _rehash(self):
        oldtable = self._table
        newsize = len(self._table) * 2
        # 新的table
        self._table = Array(newsize, HashTable.UNUSED)
        self.length = 0
        for slot in oldtable:
            if slot is not HashTable.UNUSED and slot is not HashTable.EMPTY:
                index = self._find_slot_insert(slot.key)
                self._table[index] = slot
                self.length += 1

    def get(self, key, default=None):
        index = self._find_key(key)
        if index is None:
            return default
        else:
            return self._table[index].value

    def remove(self, key):
        index = self._find_key(key)
        if index is None:
            raise KeyError
        value = self._table[index].value
        self.length -= 1
        # 把槽设置为空槽
        self._table[index] = HashTable.EMPTY
        return value

    def __iter__(self):
        for slot in self._table:
            if slot not in (HashTable.UNUSED, HashTable.EMPTY):
                yield slot.value