数据结构与算法（21）——映射抽象数据类型

• 抽象数据类型“映射”：ADT Map（映射Map）

ADT Map 操作定义：

Map()：创建一个空映射，返回空映射对象；

put(key, val)：将key-val关联对加入映射中 ，如果key已存在，将val替换旧关联值；

get(key)：给定key，返回关联的数据值，如不 存在，则返回None；

del：通过del map[key]的语句形式删除key-val关联；

len()：返回映射中key-val关联的数目；

in：通过key in map的语句形式，返回key是否 存在于关联中，布尔值

• 实现ADT Map

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)

        if self.slots[hashvalue] == None: #如果key不存在，未冲突
            self.slots[hashvalue] = key
            self.data[hashvalue] = data
        else:
            if self.slots[hashvalue] == key:
                self.data[hashvalue] = data #如果key已经存在，则替换key
            else:
                nextslot = self.rehash(hashvalue) #如果hash冲突，再散列
                while self.slots[nextslot] != None and self.slots[nextslot] != key:
                    nextslot = self.rehash(nextslot)

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

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

        data = None
        stop = None
        found = None
        position = startslot
        # 查找key，直到空槽或回到起点
        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)  # 未找到，再散列继续查找
                if position == startslot:  # 回到起点，停止
                    stop = True
        return data

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

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

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

    def __setitem__(self, key, data):
        self.put(key,data)
H = HashTable()
H[54] = "cat"
H[26] = "dog"
H[93] = "lion"
H[17] = "tiger"
H[77] = "bird"
H[31] = "cow"
H[44] = "goat"
H[55] = "pig"
H[20] = "chicken"
print(H.slots)
print(H.data)
print(H[20])
print(H[17])
H[20] = "duck"
print(H[20])
print(H[99])

运行结果

[77, 44, 55, 20, 26, 93, 17, None, None, 31, 54]
['bird', 'goat', 'pig', 'chicken', 'dog', 'lion', 'tiger', None, None, 'cow', 'cat']
chicken
tiger
duck
None

Process finished with exit code 0