散列链地址法的时间复杂度和空间复杂度

散列链地址法是一种常见的散列表实现方法，其时间复杂度和空间复杂度如下：

时间复杂度：
- 查找、插入、删除操作的平均时间复杂度为O(1+α)，其中α=n/m，n为散列表中元素个数，m为散列表中槽位个数。
- 当α较小时，散列链地址法的性能较好，但当α较大时，冲突的概率增加，性能会下降。

空间复杂度：
- 散列链地址法的空间复杂度为O(n+m)，其中n为散列表中元素个数，m为散列表中槽位个数。
- 当α较小时，m可以取得较小，空间利用率较高，但当α较大时，m需要取得较大，空间利用率会下降。

下面是一个使用散列链地址法实现的Python代码示例：

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.next = None

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [None] * self.size

    def hash_function(self, key):
        return key % self.size

    def insert(self, key, value):
        index = self.hash_function(key)
        node = self.table[index]
        while node:
            if node.key == key:
                node.value = value
                return
            node = node.next
        new_node = Node(key, value)
        new_node.next = self.table[index]
        self.table[index] = new_node

    def search(self, key):
        index = self.hash_function(key)
        node = self.table[index]
        while node:
            if node.key == key:
                return node.value
            node = node.next
        return None

    def delete(self, key):
        index = self.hash_function(key)
        node = self.table[index]
        prev = None
        while node:
            if node.key == key:
                if prev:
                    prev.next = node.next
                else:
                    self.table[index] = node.next
                return
            prev = node
            node = node.next