数据结构Python实现之哈希表，字典以及集合

哈希表：

class Array(object):#定义一个数组，用于实现哈希表
    def __init__(self,size=32,init=None):
        self._size = size
        self._items = [init] * 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

'''
定义一个hash表数组的槽
注意，一个槽有三种状态。
1.从未使用HashTable.UNUSED。此槽没有被使用和冲突过，查找时只要找到UNUSED就不用再继续探查了
2.使用过但是remove了，此时是HashTable.EMPTY，该探查点后边的元素扔可能是有key
3.槽正在使用Slot节点
'''
class Slot(object):
    def __init__(self,key,value):
        self.key = key
        self.value = 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):#装载因子(load factor)，当装载因子超过某一阈值时，需要进行重哈希操作
        return self.length/float(len(self._table))
    def __len__(self):#哈希表的长度
        return self.length
    def _hash(self,key):#定义hash函数，返回哈希表数组的索引
        return abs(hash(key))%len(self._table)
    def _find_key(self,key):#搜寻key键，如果存在，返回key键对应的索引，否则返回None
        index = self._hash(key)
        _len = len(self._table)
        while self._table[index] is not HashTable.UNUSED:
            if self._table[index] is HashTable.EMPTY:
                index = (index*5 +1)%_len#解决哈希冲突的一种方式
                continue
            elif self._table[index].key == key:
                return index
            else:
                index = (index*5 + 1)%_len
        return None
    def _find_slot_for_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
    def _slot_can_insert(self,index):#判断发现的槽能否插入，空槽或从未被使用即返回True
        return (self._table[index] is HashTable.EMPTY or self._table[index] is HashTable.UNUSED)
    def __contains__(self, key):#in 操作符，判断key是否在hash表里，如果存在返回其索引，否则返回None
        index = self._find_key(key)
        return index is not None
    def add(self,key,value):#添加元素操作，有 key 则更新，否则插入
        if key in self:#调用__contains__判断key是否在哈希表中
            index = self._find_key(key)#搜寻key的索引
            self._table[index].value = value#更新哈希表中key对应的value
            return False
        else:#如果key不再hash表中，则添加元素Slot(key,value),并更新长度
            index = self._find_slot_for_insert(key)
            self._table[index] = Slot(key,value)
            self.length += 1
            if self._load_factor >= 0.8:#如果装载因子大于0.8，则进行重哈希操作
                self._rehash()
            return True

# '''
# 重哈希(Rehashing)，
# 步骤就是重新开辟一块新的空间。本函数里的策略是扩大为已经使用的槽数目的两倍。
# 开辟了新空间以后，会把原来哈希表里不为空槽的数据重新插入到新的哈希表里，
# 插入方式和之前一样。这就是 rehashing 操作。
# '''
    def _rehash(self):
        old_table = self._table
        newsize = len(self._table) * 2
        self._table = Array(newsize,HashTable.UNUSED)#定义新的哈希表
        self.length = 0#初始长度为0
        for slot in old_table:#把原来哈希表里不为空槽的数据重新插入到新的哈希表里
            if slot is not HashTable.UNUSED and slot is not HashTable.EMPTY:
                index = self._find_slot_for_insert(slot.key)
                self._table[index]=slot
                self.length += 1
    def get(self,key,default = None):#获取 key 的值，不存在返回默认值 None
        index = self._find_key(key)
        if index is None:
            return default
        else:
            return self._table[index].value
    def remove(self,key):#删除一个 key，这里其实不是真删除，而是标记为 Empty
        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.EMPTY,HashTable.UNUSED):
                yield slot.key
'''
添加操作：
h = HashTable()
h.add('a', 0)
h.add('b', 1)
h.add('c', 2)
print('hash表的长度为:',len(h))
print(h.get('a')==0)
print(h.get('b')==1)
print(h.get('c')==2)
print(h.get('w') is None)
print('遍历输出：')
for i in h:
    print(i,':',h.get(i),end=',')

输出：
hash表的长度为: 3
True
True
True
True
遍历输出：
b : 1,c : 2,a : 0,
'''
'''
删除操作：
h = HashTable()
h.add('a', 0)
h.add('b', 1)
h.add('c', 2)
h.add('x', 10)
h.add('y', 11)
h.add('z', 12)
print('hash表的长度为:',len(h))
print('get()返回值:',h.get('a'),';','remove()返回值:',h.remove('a'))
print('get()返回值:',h.get('c'),';','remove()返回值:',h.remove('c'))
print('get()返回值:',h.get('x'),';','remove()返回值:',h.remove('x'))
print('删除操作后hash表的长度为:',len(h))
print('遍历输出：')
for i in h:
    print(i,':',h.get(i),end=',')
输出：
hash表的长度为: 6
get()返回值: 0 ; remove()返回值: 0
get()返回值: 2 ; remove()返回值: 2
get()返回值: 10 ; remove()返回值: 10
删除操作后hash表的长度为: 3
遍历输出：
y : 11,z : 12,b : 1,
'''
'''
重哈希
h = HashTable()#哈希表的默认大小为8
for i in range(20):#添加元素超过装载因子，此时会进行重哈希操作
    h.add(i, i)
for i in range(20):
    print(h.get(i)==i,end=',')

print('hash表的长度为:',len(h))

输出：
True,True,True,True,True,True,True,True,
True,True,True,True,True,True,True,True,
True,True,True,True,
hash表的长度为: 20
'''

字典：

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

class Hashable(object):
    UNUSED = None
    EMPTY = Slot(None,None)

    def __init__(self):
        self._table = Array(8,init=Hashable.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)
        while self._table[index] is not Hashable.UNUSED:
            if self._table[index] is Hashable.EMPTY:
                index = (index * 5 + 1 )%_len
                continue
            elif self._table[index].key==key:
                return index
            else:
                index = (index * 5 + 1)%_len
        return None
    def _find_slot_for_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
    def _slot_can_insert(self,index):
        return (self._table[index] is Hashable.EMPTY or self._table[index] is Hashable.UNUSED)
    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_for_insert(key)
            self._table[index] = Slot(key,value)
            self.length += 1
            if self._load_factor>=0.8:
                self._rehash()
            return True
    def _rehash(self):
        old_table = self._table
        newsize = len(self._table)*2
        self._table = Array(newsize,Hashable.UNUSED)
        self.length = 0
        for slot in old_table:
            if slot is not Hashable.UNUSED and slot is not Hashable.EMPTY:
                index = self._find_slot_for_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] = Hashable.EMPTY
        return value
    def __iter__(self):
        for slot in self._table:
            if slot not in (Hashable.EMPTY,Hashable.UNUSED):
                yield slot.key

class Dict(Hashable):

    def _iter_slot(self):
        for slot in self._table:
            if slot not in (Hashable.EMPTY,Hashable.UNUSED):
                yield slot
    def __setitem__(self, key, value):
        self.add(key,value)
    def __getitem__(self, key):
        if key not in self:
            raise KeyError()
        else:
            return self.get(key)
    def items(self):
        for slot in self._iter_slot():
            yield (slot.key,slot.value)
    def keys(self):
        for slot in self._iter_slot():
            yield slot.key
    def values(self):
        for slot in self._iter_slot():
            yield slot.value
# '''
# 通过指定的key值，删除字典的一个键值对
# 返回被删除的key对应的value
# '''
    def pop(self,key):
        return self.remove(key)
    def clear(self):#清空字典
        for index in range(len(self._table)):
            self._table[index] = Hashable.EMPTY
    def update(self,other):
        self_list=[]
        other_list=[]
        for key,value in self.items():
            self_list.append((key,value))
        for key,value in other.items():
            other_list.append((key,value))
        copy_list = self_list.copy()
        copy_list.extend(other_list)
        for key_value in set(copy_list):
            if key_value in other_list and key_value not in self_list:
                self.add(key_value[0],key_value[1])
            else:
                continue


'''
d = Dict()
d['a']=1
d['b']=2
d['c']=3
d['d']=4
d['e']=5
print('字典长度：',len(d))
print('遍历字典：')
for key,value in d.items():
    print((key,value))
print('key,get(key)获取键值对：')
for key in d.keys():
    print((key,d.get(key)))

输出：
字典长度： 5
遍历字典：
('d', 4)
('b', 2)
('e', 5)
('a', 1)
('c', 3)
key,get(key)获取键值对：
('d', 4)
('b', 2)
('e', 5)
('a', 1)
('c', 3)
'''

'''
d = Dict()
d['a']=1
d['b']=2
d['c']=3
d['d']=4
d['e']=5
d.pop('a')
d.pop('d')
for key,value in d.items():
    print((key,value))
输出：
('e', 5)
('b', 2)
('c', 3)
'''
'''
d = Dict()
d['a']=1
d['b']=2
d['c']=3
d['d']=4
d['e']=5
d.clear()
for key,value in d.items():
    print((key,value))
'''
'''
当d1和d2的键没有交集的时候
d1=Dict()
d2=Dict()
d1['a']=1
d1['b']=2
d1['c']=3
d2['x']=11
d2['y']=22
d2['z']=33
print('d1:')
for key,value in d1.items():
    print((key,value))
print('d2:')
for key,value in d2.items():
    print((key,value))
d1.update(d2)
print('更新后的d1:')
for key,value in d1.items():
    print((key,value))
输出：
d1:
('c', 3)
('a', 1)
('b', 2)
d2:
('y', 22)
('z', 33)
('x', 11)
更新后的d1:
('c', 3)
('y', 22)
('a', 1)
('z', 33)
('b', 2)
('x', 11)

'''
'''
当d1和d2的键有交集的时候
d1=Dict()
d2=Dict()
d1['a']=1
d1['b']=2
d1['c']=3
d2['a']=1
d2['b']=22
d2['x']=33
print('d1:')
for key,value in d1.items():
    print((key,value))
print('d2:')
for key,value in d2.items():
    print((key,value))
d1.update(d2)
print('更新后的d1:')
for key,value in d1.items():
    print((key,value))
输出：
d1:
('a', 1)
('c', 3)
('b', 2)
d2:
('a', 1)
('x', 33)
('b', 22)
更新后的d1:
('a', 1)
('c', 3)
('x', 33)
('b', 22)
'''

集合：

class Set(HashTable):
    def add(self,key):
        # 集合其实就是一个 dict，只不过我们把它的 value 设置成 1
        return super(Set,self).add(key,True)
    def __and__(self, other):
        #交集: A & B，表示同时在 A 和 B 中的元素。 python 中重载  `__and__` 实现
        new_set = Set()
        for element_a in self:
            if element_a in other:
                new_set.add(element_a)
        return new_set
    def __sub__(self, other):
        # 差集:  A - B，表示在 A 中但是不在 B 中的元素。 python 中重载 `__sub__` 实现
        new_set = Set()
        for element_a in self:
            if element_a not in other:
                new_set.add(element_a)
        return new_set
    def __or__(self, other):
        #并集: A | B，表示在 A 或者 B 中的元素，两个集合相加。python 中重载 `__or__` 实现
        new_set = Set()
        for element_a in self:
            new_set.add(element_a)
        for element_b in other:
            new_set.add(element_b)
        return new_set
    def __xor__(self, other):#对称差: A ^ B，返回在 A 或 B 但是不在 A、B 中都出现的元素。其实就是 (A|B) - (A&B)， python 中重载 `__xor__` 实现
        new_set= Set()
        for element_a in self:
            if element_a not in other:
                new_set.add(element_a)
        for element_b in other:
            if element_b not in self:
                new_set.add(element_b)
        return new_set
    def pop(self):#删除集合中的第一个元素
        for element in self:
            self.remove(element)
            break
    def remove(self, key):#删除集合中指定的元素
        super(Set,self).remove(key)
'''
remove()操作
s1=Set()
s1.add(1)
s1.add(6)
s1.add(4)
s1.add(9)
s1.add(3)
s1.add(8)
print(list(s1))
s1.remove(8)
print(list(s1))
s1.remove(1)
print(list(s1))
s1.remove(4)
print(list(s1))
s1.remove(9)
print(list(s1))
输出：
[8, 1, 3, 4, 6, 9]
[1, 3, 4, 6, 9]
[3, 4, 6, 9]
[3, 6, 9]
[3, 6]
'''
'''
pop()操作
s1=Set()
s1.add(1)
s1.add(6)
s1.add(4)
s1.add(9)
s1.add(3)
s1.add(8)
print(list(s1))
s1.pop()
print(list(s1))
s1.pop()
print(list(s1))
s1.pop()
print(list(s1))
s1.pop()
print(list(s1))
s1.pop()
print(list(s1))
输出：
[8, 1, 3, 4, 6, 9]
[1, 3, 4, 6, 9]
[3, 4, 6, 9]
[4, 6, 9]
[6, 9]
[9]
'''
'''
s1=Set()
s1.add(1)
s1.add(2)
s1.add(3)
print(1 in s1)
s2=Set()
s2.add(1)
s2.add(0)
s2.add(3)
s2.add(7)
s2.add(8)
s2.add(9)
print('s1和s2的交集：')
print(list(s1 & s2))
print('s1和s2的差集：')
print(list(s1 - s2))
print('s2和s1的差集：')
print(list(s2 - s1))
print('s1和s2的并集：')
print(list(s2 | s1))
print('s1和s2的对称差：')
print(list(s1 ^ s2))
输出：
True
s1和s2的交集：
[1, 3]
s1和s2的差集：
[2]
s2和s1的差集：
[0, 9, 8, 7]
s1和s2的并集：
[0, 1, 2, 3, 7, 8, 9]
s1和s2的对称差：
[0, 9, 2, 8, 7]
'''