Python与数据结构[4] -> 散列表[1] -> 分离链接法的 Python 实现

分离链接法 / Separate Chain Hashing

---

前面完成了一个基本散列表的实现，但是还存在一个问题，当散列表插入元素冲突时，散列表将返回异常，这一问题的解决方式之一为使用链表进行元素的存储，即分离链接法。

Separate Chain Hashing:
        [0]  Header->11->0->110
        [1]  Header->12->1->111
        [2]  Header->2->112
        [3]  Header->14->3->113
        [4]  Header->15->4->114
        [5]  Header->16->5
        [6]  Header->17->6
        [7]  Header->18->7
        [8]  Header->19->8
        [9]  Header->9
        [10] Header->10

而在利用链表实现分离链接法时，可选用带表头的链表，插入元素时采用前端插入，每次将新元素插入对应散列位置链表的最前端，因为新插入的元素往往被查找的概率较大，放在前面便于缩短查找时间。

下面利用代码实现散列表的分离链接法，

完整代码

 from hash_table import HashTable, kmt_hashing
 from linked_list.linked_list_dummy_header import LinkedListDummyHeader as List

 class SeparateChainHashing(HashTable):
     """
     Separate Chain Hashing:
         [0]  Header->11->0->110
         [1]  Header->12->1->111
         [2]  Header->2->112
         [3]  Header->14->3->113
         [4]  Header->15->4->114
         [5]  Header->16->5
         [6]  Header->17->6
         [7]  Header->18->7
         [8]  Header->19->8
         [9]  Header->9
         [10] Header->10
     """
     def __init__(self, size, fn):
         self._array = [List() for i in range(size)]
         self._hashing = fn

     def find(self, item):
         linked_list = self._array[self._hashing(item)]
         node = linked_list.header.next
         while node and node.value != item:
             node = node.next
         return node

     def _insert(self, item):
         """
                    item
                     |
                     V
         [n]  Header->node_1->node_2->node_3
         """
         if item is None:
             return
         linked_list = self._array[self._hashing(item)]
         node = linked_list.header
         while node.next:
             if node.next.value == item:  # Element existed
                 return
             node = node.next
         linked_list.insert(item, 1)

     def delete(self, item):
         linked_list = self._array[self._hashing(item)]
         linked_list.delete(item)

     def show(self):
         print(self)

     @property
     def load_factor(self):
         element_num = sum(x.length-1 for x in self._array)
         return element_num/self.size

     def make_empty(self):
         # self._array = [List() for i in range(len(self._array))]
         for chain in self._array:
             chain.clear()

 def test(h):
     print('\nShow hash table:')
     h.insert(110, 111, 112, 113, 114)
     h.insert(range(20))
     h.delete(13)
     h.show()
     print('\nLoad factor is:', h.load_factor)
     print('\nClear hash table:')
     h.make_empty()
     h.show()

 if __name__ == '__main__':
     test(SeparateChainHashing(11, kmt_hashing(11)))

分段解释

首先导入散列表和散列函数，以及需要用到的带表头链表，

 from hash_table import HashTable, kmt_hashing
 from linked_list.linked_list_dummy_header import LinkedListDummyHeader as List

接着基于散列表派生一个实现分离链接法的散列表类，

 class SeparateChainHashing(HashTable):
     """
     Separate Chain Hashing:
         [0]  Header->11->0->110
         [1]  Header->12->1->111
         [2]  Header->2->112
         [3]  Header->14->3->113
         [4]  Header->15->4->114
         [5]  Header->16->5
         [6]  Header->17->6
         [7]  Header->18->7
         [8]  Header->19->8
         [9]  Header->9
         [10] Header->10
     """
     def __init__(self, size, fn):
         self._array = [List() for i in range(size)]
         self._hashing = fn

重载find方法，在查找到散列值对应的链表后，遍历链表查询目标值，

     def find(self, item):
         linked_list = self._array[self._hashing(item)]
         node = linked_list.header.next
         while node and node.value != item:
             node = node.next
         return node

重载_insert方法，插入元素时，向链表表头后的第一个位置进行插入，

     def _insert(self, item):
         """
                    item
                     |
                     V
         [n]  Header->node_1->node_2->node_3
         """
         if item is None:
             return
         linked_list = self._array[self._hashing(item)]
         node = linked_list.header
         while node.next:
             if node.next.value == item:  # Element existed
                 return
             node = node.next
         linked_list.insert(item, 1)

重载delete方法，删除元素较为简单，查找到散列值对应的链表后，使用链表的删除函数即可，

     def delete(self, item):
         linked_list = self._array[self._hashing(item)]
         linked_list.delete(item)

最后，分别完成显示散列表，计算装填因子和清空散列表的函数，

     def show(self):
         print(self)

     @property
     def load_factor(self):
         element_num = sum(x.length-1 for x in self._array)
         return element_num/self.size

     def make_empty(self):
         # self._array = [List() for i in range(len(self._array))]
         for chain in self._array:
             chain.clear()

完成散列表类后，再写一个测试函数，用于测试散列表，以 11 为散列表大小初始化一个散列表进行测试

 def test(h):
     print('\nShow hash table:')
     h.insert(110, 111, 112, 113, 114)
     h.insert(range(20))
     h.delete(13)
     h.show()
     print('\nLoad factor is:', h.load_factor)
     print('\nClear hash table:')
     h.make_empty()
     h.show()

 if __name__ == '__main__':
     test(SeparateChainHashing(11, kmt_hashing(11)))

最后得到结果

Show hash table:
[0] Header->11->0->110
[1] Header->12->1->111
[2] Header->2->112
[3] Header->14->3->113
[4] Header->15->4->114
[5] Header->16->5
[6] Header->17->6
[7] Header->18->7
[8] Header->19->8
[9] Header->9
[10] Header->10

Load factor is: 2.1818181818181817

Clear hash table:
[0] Header
[1] Header
[2] Header
[3] Header
[4] Header
[5] Header
[6] Header
[7] Header
[8] Header
[9] Header
[10] Header

可以看到，由于链表的存在，冲突被很好的解决了。而另一种冲突解决方式，可参考相关阅读中的开放定址法。

相关阅读

---

1. 散列表

2. 开放定址法