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应为一个素数。

完整代码

  1 from collections import Iterable
  2 
  3 
  4 class CollisionError(Exception):
  5     pass
  6 
  7 
  8 class HashTable:
  9     """
 10     Hash Table:
 11         [0] -> A
 12         [1] -> B
 13         [2] -> C
 14         [3] -> D
 15         [4] -> E
 16     """
 17     def __init__(self, size, fn):
 18         self._array = [None for i in range(size)]
 19         self._hashing = fn
 20 
 21     def __str__(self):
 22         return '\n'.join('[%d] %s' % (index, item) for index, item in enumerate(self._array))
 23 
 24     def find(self, item):
 25         hash_code = self._hashing(item)
 26         value = self._array[hash_code]
 27         return value if value == item else None, hash_code
 28 
 29     def insert(self, *args):
 30         for i in args:
 31             if isinstance(i, Iterable):
 32                 for j in i:
 33                     self._insert(j)
 34             else:
 35                 self._insert(i)
 36 
 37     def _insert(self, item):
 38         if item is None:
 39             return
 40         hash_code = self._hashing(item)
 41         value = self._array[hash_code]
 42         if value is not None and value != item:      # Handle value 0 and value existed situation.
 43             raise CollisionError('Hashing value collided!')
 44         self._array[hash_code] = item
 45 
 46     def delete(self, item):
 47         hash_code = self._hashing(item)
 48         if self._array[hash_code] != item:
 49             raise KeyError('Key error with %s' % item)
 50         self._array[hash_code] = None
 51 
 52     def show(self):
 53         print(self)
 54 
 55     @property
 56     def size(self):
 57         return len(self._array)
 58 
 59     @property
 60     def load_factor(self):
 61         element_num = sum(map(lambda x: 0 if x is None else 1, self._array))
 62         return element_num/self.size
 63 
 64     def make_empty(self):
 65         self._array = [None for i in range(self.size)]
 66 
 67 
 68 def kmt_hashing(size):
 69     # Key = Key mod TableSize
 70     return lambda x: x % size
 71 
 72 
 73 def test(h):
 74     print('\nShow hash table:')
 75     h.show()
 76 
 77     print('\nInsert values:')
 78     h.insert(7, 8, 9)
 79     h.insert(range(7))
 80     h.show()
 81     print('\nInsert values (existed):')
 82     h.insert(1)
 83     h.show()
 84     print('\nInsert value (collided):')
 85     try:
 86         h.insert(11)
 87     except CollisionError as e:
 88         print(e)
 89 
 90     print('\nFind value:')
 91     print(h.find(7))
 92     print('\nFind value (not existed):')
 93     print(h.find(77))
 94 
 95     print('\nDelete value:')
 96     h.delete(7)
 97     h.show()
 98     print('\nDelete value (not existed):')
 99     try:
100         h.delete(111)
101     except KeyError as e:
102         print(e)
103 
104     print('\nLoad factor is:', h.load_factor)
105     print('\nClear hash table:')
106     h.make_empty()
107     h.show()
108 
109 if __name__ == '__main__':
110     test(HashTable(10, kmt_hashing(10)))
View Code

分段解释

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

1 from collections import Iterable
2 
3 
4 class CollisionError(Exception):
5     pass

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

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

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

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

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

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

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

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

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

 1     def insert(self, *args):
 2         for i in args:
 3             if isinstance(i, Iterable):
 4                 for j in i:
 5                     self._insert(j)
 6             else:
 7                 self._insert(i)
 8 
 9     def _insert(self, item):
10         if item is None:
11             return
12         hash_code = self._hashing(item)
13         value = self._array[hash_code]
14         if value is not None and value != item:      # Handle value 0 and value existed situation.
15             raise CollisionError('Hashing value collided!')
16         self._array[hash_code] = item

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

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

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

 1     def show(self):
 2         print(self)
 3 
 4     @property
 5     def size(self):
 6         return len(self._array)
 7 
 8     @property
 9     def load_factor(self):
10         element_num = sum(map(lambda x: 0 if x is None else 1, self._array))
11         return element_num/self.size
12 
13     def make_empty(self):
14         self._array = [None for i in range(self.size)]

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

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

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

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

1 def test(h):
2     print('\nShow hash table:')
3     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

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

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

得到结果

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

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

1     print('\nInsert values (existed):')
2     h.insert(1)
3     h.show()
4     print('\nInsert value (collided):')
5     try:
6         h.insert(11)
7     except CollisionError as e:
8         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!

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

1     print('\nFind value:')
2     print(h.find(7))
3     print('\nFind value (not existed):')
4     print(h.find(77))

得到结果

Find value:
(7, 7)

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

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

1     print('\nDelete value:')
2     h.delete(7)
3     h.show()
4     print('\nDelete value (not existed):')
5     try:
6         h.delete(111)
7     except KeyError as e:
8         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'

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

1     print('\nLoad factor is:', h.load_factor)
2     print('\nClear hash table:')
3     h.make_empty()
4     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. 开放定址法

posted @ 2018-01-16 19:16  StackLike  阅读(709)  评论(0)  编辑  收藏  举报