Python与数据结构[4] -> 散列表[0] -> 散列表与散列函数的 Python 实现

散列表 / Hash Table

---

散列表与散列函数

散列表是一种将关键字映射到特定数组位置的一种数据结构，而将关键字映射到0至TableSize-1过程的函数，即为散列函数。

Hash Table:
        [0] -> A
        [1] -> B
        [2] -> C
        [3] -> D
        [4] -> E

下面以一个简单的散列函数 Hash(Key)=Key mod TableSize为例，完成一个散列表的实现。

Note: 为方便起见，这里选用了一个非素数作为TableSize，适宜的TableSize应为一个素数。

完整代码

 from collections import Iterable
 
 class CollisionError(Exception):
     pass
 
 class HashTable:
     """
     Hash Table:
         [0] -> A
         [1] -> B
         [2] -> C
         [3] -> D
         [4] -> E
     """
     def __init__(self, size, fn):
         self._array = [None for i in range(size)]
         self._hashing = fn
 
     def __str__(self):
         return '\n'.join('[%d] %s' % (index, item) for index, item in enumerate(self._array))
 
     def find(self, item):
         hash_code = self._hashing(item)
         value = self._array[hash_code]
         return value if value == item else None, hash_code
 
     def insert(self, *args):
         for i in args:
             if isinstance(i, Iterable):
                 for j in i:
                     self._insert(j)
             else:
                 self._insert(i)
 
     def _insert(self, item):
         if item is None:
             return
         hash_code = self._hashing(item)
         value = self._array[hash_code]
         if value is not None and value != item:      # Handle value 0 and value existed situation.
             raise CollisionError('Hashing value collided!')
         self._array[hash_code] = item
 
     def delete(self, item):
         hash_code = self._hashing(item)
         if self._array[hash_code] != item:
             raise KeyError('Key error with %s' % item)
         self._array[hash_code] = None
 
     def show(self):
         print(self)
 
     @property
     def size(self):
         return len(self._array)
 
     @property
     def load_factor(self):
         element_num = sum(map(lambda x: 0 if x is None else 1, self._array))
         return element_num/self.size
 
     def make_empty(self):
         self._array = [None for i in range(self.size)]
 
 def kmt_hashing(size):
     # Key = Key mod TableSize
     return lambda x: x % size
 
 def test(h):
     print('\nShow hash table:')
     h.show()
 
     print('\nInsert values:')
     h.insert(7, 8, 9)
     h.insert(range(7))
     h.show()
     print('\nInsert values (existed):')
     h.insert(1)
     h.show()
     print('\nInsert value (collided):')
     try:
         h.insert(11)
     except CollisionError as e:
         print(e)
 
     print('\nFind value:')
     print(h.find(7))
     print('\nFind value (not existed):')
     print(h.find(77))
 
     print('\nDelete value:')
     h.delete(7)
     h.show()
     print('\nDelete value (not existed):')
     try:
         h.delete(111)
     except KeyError as e:
         print(e)
 
     print('\nLoad factor is:', h.load_factor)
     print('\nClear hash table:')
     h.make_empty()
     h.show()
 
 if __name__ == '__main__':
     test(HashTable(10, kmt_hashing(10)))

分段解释

首先导入一个可迭代类，用于判断参数类型时使用，并定义一个散列冲突异常类

 from collections import Iterable
 
 class CollisionError(Exception):
     pass

接着定义一个散列表类，构造函数接收两个参数，一个用于设置散列表的大小，一个用于设置散列函数，

Note: 由于Python的列表无法像C语言中的数组一样提前声明大小，因此这里的列表需要先用None进行填充。

 class HashTable:
     """
     Hash Table:
         [0] -> A
         [1] -> B
         [2] -> C
         [3] -> D
         [4] -> E
     """
     def __init__(self, size, fn):
         self._array = [None for i in range(size)]
         self._hashing = fn

再重载__str__方法，用于更加清晰的显示散列表，

     def __str__(self):
         return '\n'.join('[%d] %s' % (index, item) for index, item in enumerate(self._array))

定义散列表的find方法，find方法的时间复杂度为O(1)，查找时仅需根据键值计算哈希值，再从散列表中获取元素即可。返回查找到的结果和对应哈希值，若未找到元素则返回None和最后查找的位置。

Note: O(1)的前提是散列函数足够简单快速

     def find(self, item):
         hash_code = self._hashing(item)
         value = self._array[hash_code]
         return value if value == item else None, hash_code

定义散列表的insert方法，首先对传入的参数进行判断，若为可迭代对象则迭代插入，否则直接插入。私有的插入方法将利用散列函数对插入值进行散列计算，然后插入对应位置，若对应位置已被占有，则引发一个冲突异常。

     def insert(self, *args):
         for i in args:
             if isinstance(i, Iterable):
                 for j in i:
                     self._insert(j)
             else:
                 self._insert(i)
 
     def _insert(self, item):
         if item is None:
             return
         hash_code = self._hashing(item)
         value = self._array[hash_code]
         if value is not None and value != item:      # Handle value 0 and value existed situation.
             raise CollisionError('Hashing value collided!')
         self._array[hash_code] = item

定义散列表的delete方法，当需要删除某个值时，同样先进行散列计算，找到对应散列位置，若该位置的值与删除值不同，则引发一个键错误异常，若相同或为None，则直接删除该元素。

     def delete(self, item):
         hash_code = self._hashing(item)
         if self._array[hash_code] != item:
             raise KeyError('Key error with %s' % item)
         self._array[hash_code] = None

接着定义散列表几个基本方法，包括显示散列表，获取散列表大小，计算装填因子和清空散列表。

     def show(self):
         print(self)
 
     @property
     def size(self):
         return len(self._array)
 
     @property
     def load_factor(self):
         element_num = sum(map(lambda x: 0 if x is None else 1, self._array))
         return element_num/self.size
 
     def make_empty(self):
         self._array = [None for i in range(self.size)]

最后，定义一个简单的散列函数Hash(Key)=Key mode TableSize。

 def kmt_hashing(size):
     # Key = Key mod TableSize
     return lambda x: x % size

以及一个测试函数，对散列表进行测试。

首先显示一个初始的散列表，

 def test(h):
     print('\nShow hash table:')
     h.show()

得到结果

Show hash table:
[0] None
[1] None
[2] None
[3] None
[4] None
[5] None
[6] None
[7] None
[8] None
[9] None

接着测试插入方法，向散列表中插入元素

     print('\nInsert values:')
     h.insert(7, 8, 9)
     h.insert(range(7))
     h.show()

得到结果

Insert values:
[0] 0
[1] 1
[2] 2
[3] 3
[4] 4
[5] 5
[6] 6
[7] 7
[8] 8
[9] 9

尝试插入已存在的元素，则没有影响，而尝试插入一个冲突元素，则会引发一个冲突异常

     print('\nInsert values (existed):')
     h.insert(1)
     h.show()
     print('\nInsert value (collided):')
     try:
         h.insert(11)
     except CollisionError as e:
         print(e)

显示结果

Insert values (existed):
[0] 0
[1] 1
[2] 2
[3] 3
[4] 4
[5] 5
[6] 6
[7] 7
[8] 8
[9] 9
 
Insert value (collided):
Hashing value collided!

尝试查找一个存在的元素和一个不存在的元素

     print('\nFind value:')
     print(h.find(7))
     print('\nFind value (not existed):')
     print(h.find(77))

得到结果

Find value:
(7, 7)
 
Find value (not existed):
(None, 7)

尝试删除一个存在元素和一个不存在的元素

     print('\nDelete value:')
     h.delete(7)
     h.show()
     print('\nDelete value (not existed):')
     try:
         h.delete(111)
     except KeyError as e:
         print(e)

得到结果

Delete value:
[0] 0
[1] 1
[2] 2
[3] 3
[4] 4
[5] 5
[6] 6
[7] None
[8] 8
[9] 9
 
Delete value (not existed):
'Key error with 111'

查看装载因子，最后清空散列表

     print('\nLoad factor is:', h.load_factor)
     print('\nClear hash table:')
     h.make_empty()
     h.show()

得到结果

Load factor is: 0.9
 
Clear hash table:
[0] None
[1] None
[2] None
[3] None
[4] None
[5] None
[6] None
[7] None
[8] None
[9] None

一个基本的散列表基本建立完成，但还存在一个插入冲突的问题没有解决，对于插入冲突现象，解决的方式主要有分离链接法和开放定址法，具体内容可参考相关阅读。

相关阅读

---

1. 分离链接法

2. 开放定址法