python数据结构学习笔记-2016-11-18-01-散列表ADT

        11.5 散列表ADT

         散列表ADT的实现代码如下：

#-*-coding: utf-8-*-

# 散列表ADT的实现

from myarray import Array

class HashMap(object):
    # 定义散列表中每一项中状态的常数
    UNUSED = None
    EMPTY = _MapEntry(None, None) # 标记此位置使用过

    def __init__(self):
        self._table = Array(7) # 底层数组，可扩容
        self._count = 0 # 当前关键码的数量
        self._maxCount = len(self._table) - len(self._table) / 3 # 当前底层数组所能容纳的最大关键码数量，大约为底层数组长度的2/3。

    # 返回当前关键码数量
    def __len__(self):
        return self._count

    # 判断散列表中是否含给定关键码
    def __contains__(self, key):
        slot = self._findSlot(key, False) # 执行搜索，寻找槽，若存在返回True，反之返回False
        return slot is not None

    # 添加键值对
    def add(self, key, value):
        if key in self:
            slot = self._findSlot(key, False) # 执行搜索，forInsert参数为False
            self._table[slot].value = value # 将相应值修改
            return False
        else:
            slot = self._findSlot(key, True) # 执行插入，forInsert参数为True
            self._table[slot] = _MapEntry(key, value)
            self._count += 1
            if self._count == self._maxCount: # 查看是否需要再散列
                self._rehash()
            return True

    # 返回给定关键码对应的值
    def valueOf(self, key): 
        slot = self._findSlot(key, False) # 执行搜索，forInsert参数为False
        assert slot is not None, "Invalid map key." # 散列表必须含有给定关键码
        return self._table[slot].value

    # 删除给定关键码
    def remove(self, key):
        slot = self._findSlot(key, False)
        assert slot is not None, "Invalid map key."
        self._table[slot] = EMPTY

    # 返回散列表的迭代器
    def __iter__(self):
        pass

    # 返回关键码在散列表中的槽，注意forInsert参数，该参数在进行搜索操作时为False，进行插入操作时为True
    def _findSlot(slot, key, forInsert):
        slot = self._hash1(key) # 基位置
        step = self._hash2(key) # 探查步长
        M = len(self._table) # 散列表长度
        while self._table[slot] is not UNUSED:
            if forInsert and (self._table[slot] is UNUSED or self._table[slot] is EMPTY): # 插入
                return slot
            elif not forInsert and (self._table[slot] is not EMPTY and self._table[slot].key == key): # 搜索
                return slot
            else:
                slot = (slot + step) % M

    # 再散列
    def _rehash(self):
        origTable = self._table
        newSize = len(self._table) * 2 + 1 # 最好是大于此数的第一个素数
        self._table = Array(newSize) # _table, _count以及_maxCount都得重新设定
        self._count = 0
        self._maxCount = newSize - newSize / 3
        for entry in origTable:
            if entry is not UNUSED and entry is not EMPTY:
                slot = self._findSlot(key, True)
                self._table[slot] = entry
                self._count += 1
 
    # 主散列函数，用于求出基位置
    def _hash1(self, key):
        return abs(hash(key)) % len(self._table)

    # 用于探查的散列函数
    def _hash2(self, key):
        return 1 + abs(hash(key)) % (len(self._table) - 2)

class _MapEntry(object):
    def __init__(self, key, value):
        self.key = key
        self.value = value

        在构造器中，我们使用_table作为底层数组，_count记录当前关键码的数量，_maxCount记录在当前数组容量下，散列表所能容纳的最大关键码数目，即数组容量的2/3。在后面的_rehash()方法中，当数组扩容时，上述三个参数也做相应的改变。

        另外，本例中使用了两个散列函数，前者主要用于得出关键码的基位置，后者主要用来得出探查步长。对于所有数据类型，都使用python的内建函数hash()，先将非整数数据类型转化为整数，取绝对值，再使用除法求余数，得出基位置。

        此外，还要注意辅助方法_findSlot()的forInsert参数，如果是执行搜索，forInsert参数就为False，如果执行插入，forInsert参数就为True。

        在add()方法中，辅助方法_findSlot()执行了两次，先是判断指定关键码是否存在于散列表中，执行搜索操作，如果在，再执行一次搜索操作，得到相应的位置，更改为给定值。如果不在，则再使用_findSlot()方法进行插入操作，添加键值对，还要注意是否要扩容的问题。