python散列实现映射抽象数据类型

　　字典是最有用的Python集合之一。字典是存储键-值对数据类型。键用来查找关联的值，这个概念常常被称作映射。

　　映射抽象数据类型定义如下。它是将键和值关联起来的无序集合，其中的键是不重复的，键和值之间是一一对应的关系。映射支持以下操作。

　　 （1）Map()创建一个空的映射，它返回一个空的映射集合。

　　 （2）put(key，val)往映射中加入一个新的键-值对。如果键已经存在，就用新值替换旧值。

　　 （3）get(key)返回key对应的值。如果可以不存在，则返回None。

　　 （4）del通过del、map[key]这样的语句从映射中删除键-值对。

　　 （5）len()返回映射中存储的键-值对的数目。

　　 （6）in通过key in map这样的语句，在键存在时返回True，否则返回False。

　　使用字典的一大优势是，给定一个键，能很快找到其关联的值。为了提供这种快速查找能力，需要能支持高校搜索对的实现方案。虽然可以使用列表进行顺序搜索或二分搜索，但用散列表更好，这是因为散列搜索算法的时间复杂度可以达到O(1)。

　　代码清单使用两个列表创建HashTable类，以此实现映射抽象数据类型。其中，名为slots的列表用语存储键，名为data的列表用于存储值。量列表中的键与值一一对应。散列表的初始大小是11.尽管初始大小可以任意指定，但选用一个素数很重要，这样尽可能地提高冲突处理算法效率。

　　在代码清单中，hashfunction实现了简单的取余函数。处理冲突时，采用“加1”再散列函数的线性探测法。put函数假设，除非键已经在self.slots中，否则总是可以分配一个空槽。该函数计算初始的散列值，如果对应的槽中已经有元素，就循环运行rehash函数，直到遇见一个空槽。如果槽中已有这个键，就用新的值替换旧值。

　　同理，get函数也先计划计算初始散列值，入代码清单所示。如果值不在初始散列值对应的槽中，就使用rehash确定下一个位置。注意，第50行确保搜索一定能结束，因为不会回到初始槽中。如果遇到初始值，就说明已经检查完多有的可能的槽，并且元素必定不存在。

　　HashTable类的最后两个方法提供了额外的字典功能。我们重载__getitem__和__setitem__，以通过[ ]进行访问。这意味着创建HashTable类之后，就可以使用熟悉的索引运算符了。

class HashTable:
    def __init__(self):
        self.size = 11
        self.slots = [None] * self.size
        self.data = [None] * self.size

    def put(self, key, data):
        hashvalue = self.hashfunction(key, len(self.slots))

        if self.slots[hashvalue] == None:
            self.slots[hashvalue] = key
            self.data[hashvalue] = data

        else:
            if self.slots[hashvalue] == key:
                self.data[hashvalue] = data

            else:
                nextslot = self.rehash(hashvalue, len(self.slots))
                while self.slots[nextslot] != None and self.slots[nextslot] != key:
                    nextslot = self.rehash(nextslot, len(self.slots))

                if self.slots[nextslot] == None:
                    self.slots[nextslot] = key
                    self.data[nextslot] = data
                else:
                    self.data[nextslot] = data

    def hashfunction(self, key, size):
        return key % size

    def rehash(self, oldhash, size):
        return (oldhash + 1) % size

    def get(self, key):
        startslot = self.hashfunction(key, len(self.slots))

        data = None
        stop = False
        found = False
        position = startslot

        while self.slots[position] != None and not found and not stop:
            if self.slots[position] == key:
                found = True
                data = self.data[position]

            else:
                position = self.rehash(position, len(self.slots))
                if position == startslot:
                    stop = True

        return data

    def __getitem__(self, key):
        return self.get(key)

    def __setitem__(self, key, data):
        self.put(key, data)

if __name__ =="__main__":
    H = HashTable()
    H[54] = "cat"
    H[26] = "dog"
    H[93] = "lion"
    H[17] = "tige"
    H[77] = "bird"
    H[31] = "cow"
    H[44] = "goat"
    H[55] = "pig"
    H[20] = "chicken"
    print(H.slots)
    print(H.data)
    H[20] = "duck"
    print(H.data)
    print(H[20])