Python 数据结构与算法：链表与哈希表的结合

引言

链表和哈希表是计算机科学中常见且重要的数据结构，它们各自有着独特的特点和应用场景。在本文中，我们将介绍如何将链表和哈希表优雅地结合起来，通过Python代码实现一个简单而高效的哈希表。

链表的封装

首先，我们封装了一个简单的链表类 Linklist。这个链表类支持头插法和尾插法，以及节点的插入和删除操作。为了更好地支持迭代，我们还实现了链表的迭代器类 LinkListIterator。

class Linklist:
    class Node:
        def __init__(self, item=None):
            self.item = item  # 节点的数据
            self.next = None  # 指向下一个节点的指针

    class LinkListIterator:  # 迭代器类
        def __init__(self, node):  # 构造函数，接受一个节点作为参数
            self.node = node  # 迭代器的当前节点

        def __next__(self):
            if self.node:  # 如果有节点
                cur_node = self.node  # 当前节点
                self.node = cur_node.next  # 移动到下一个节点
                return cur_node.item  # 返回当前节点的值
            else:
                raise StopIteration  # 如果没有节点，停止迭代

        def __iter__(self):
            return self  # 返回自身，使迭代器支持迭代

    def __init__(self, iterable=None):  # 初始化，可接受一个可迭代对象作为参数
        self.head = None  # 初始时头节点为空
        self.tail = None  # 初始时尾节点为空
        if iterable:  # 如果有传入可迭代对象
            self.extend(iterable)

    def append(self, obj):  # 尾插法，向链表尾部添加节点
        s = Linklist.Node(obj)  # 创建一个新节点
        if not self.head:  # 如果链表为空
            self.head = s  # 新节点成为头节点
            self.tail = s  # 新节点成为尾节点
        else:
            self.tail.next = s  # 将新节点追加到尾部
            self.tail = s  # 更新尾节点

    def extend(self, iterable):  # 扩展链表，将可迭代对象的元素依次添加到链表尾部
        for obj in iterable:
            self.append(obj)

    def find(self, obj):  # 查找链表中是否存在指定元素
        for n in self:  # 遍历链表
            if n == obj:
                return True  # 找到元素，返回True
        else:
            return False  # 未找到元素，返回False

    def __iter__(self):  # 迭代器，使链表支持for循环
        return self.LinkListIterator(self.head)  # 返回一个迭代器实例

    def __repr__(self):
        return "<<" + ",".join(map(str, self)) + ">>"  # 返回链表的字符串表示形式

哈希表的设计

接下来，我们设计了一个哈希表类 HashTable，该类使用链表解决冲突。哈希表的大小可通过初始化参数进行指定，默认为100。我们实现了哈希函数 h 和插入方法 insert，以及查找方法 find。

class HashTable:
    def __init__(self, size=100):  # 初始化哈希表，可指定大小，默认为100
        self.size = size  # 哈希表大小
        self.T = [Linklist() for i in range(self.size)]  # 创建一个包含链表的数组

    def h(self, k):  # 哈希函数，计算键的哈希值
        return k % self.size  # 取余操作

    def insert(self, k):  # 插入键到哈希表中
        i = self.h(k)  # 计算哈希值
        if self.find(k):  # 如果键已存在
            print("Duplicated Insert")  # 输出重复插入提示
        else:
            self.T[i].append(k)  # 插入键到对应位置的链表中

    def find(self, k):  # 查找键是否存在于哈希表中
        i = self.h(k)  # 计算哈希值
        return self.T[i].find(k)  # 在对应位置的链表中查找键

结合应用示例

现在，我们来演示如何使用这个结合了链表和哈希表的数据结构。我们创建了一个哈希表实例 ht，并插入一些键值对。

ht = HashTable()
ht.insert(0)
ht.insert(100)
ht.insert(1)
ht.insert(101)
ht.insert(102)
ht.insert(502)
ht.insert(99)
print(".".join(map(str, ht.T)))
print(ht.find(4))

以上代码将输出哈希表的内部结构以及对键值4的查找结果。通过这个简单而高效的结合应用，我们可以更好地理解链表和哈希表的概念，并在实际编程中灵活运用它们。

总结

链表和哈希表是数据结构中的重要组成部分，它们在解决不同问题上有着独特的优势。通过本文的代码示例，我们展示了如何巧妙地将链表和哈希表结合起来，以应对更复杂的数据存储和检索需求。希望这个结合应用的实例能够帮助读者更深入地理解这两种数据结构的应用和设计思路。