两个链表的并集和交集| Set-3（散列）

在编程中，我们往往需要对链表进行操作，其中一个常见的操作就是查找链表的交集和并集。这时候，散列表是一个非常好的选择，因为它可以使得查找这些交集和并集的操作更快更有效率。

在这个教程中，我们将会介绍如何使用散列表来查找链表的交集和并集。

散列表

散列表是一种数据结构，可以用来存储键-值（key-value）对，其基本的操作是将键映射到一个索引地址上。具体来说，我们可以使用一个hash函数将键值映射到对应的散列表索引上，然后将值存储在该位置上，这样的话，我们就可以通过key查找对应的值。

在处理链表的交集和并集时，我们使用散列表来存储链表中的元素值。使用散列表可以将查找的时间复杂度降低到$O(1)$，从而提高查找效率。

链表的并集

链表的并集就是包含两个链表中所有元素的一个新链表。如果一个元素存在于两个链表中，那么在新链表中只出现一次。

def union(head1, head2):
    # 创建散列表
    hash_table = {}
    current_node = head1

    # 循环第一个链表，将元素值存储到散列表中
    while current_node != None:
        hash_table[current_node.value] = 1
        current_node = current_node.next

    # 循环第二个链表，如果元素值不在散列表中，则将该元素值存储到散列表中，并添加到新链表中
    current_node = head2
    while current_node != None:
        if not hash_table.get(current_node.value):
            hash_table[current_node.value] = 1
            new_node = Node(current_node.value)
            new_node.next = head1
            head1 = new_node
        current_node = current_node.next

    return head1

以上是一个Python的实现，其中，我们首先创建了一个散列表，然后循环第一个链表，将链表中的元素值存储到散列表中。接着，我们循环第二个链表，查找该链表中的元素值是否在散列表中，如果不在，则将该元素值存储到散列表中，并添加到新的链表中。

代码片段

def union(head1, head2):
    # 创建散列表
    hash_table = {}
    current_node = head1

    # 循环第一个链表，将元素值存储到散列表中
    while current_node != None:
        hash_table[current_node.value] = 1
        current_node = current_node.next

    # 循环第二个链表，如果元素值不在散列表中，则将该元素值存储到散列表中，并添加到新链表中
    current_node = head2
    while current_node != None:
        if not hash_table.get(current_node.value):
            hash_table[current_node.value] = 1
            new_node = Node(current_node.value)
            new_node.next = head1
            head1 = new_node
        current_node = current_node.next

    return head1

链表的交集

链表的交集指的是两个链表中共有的元素。我们同样可以使用散列表来实现链表的交集查找。

def intersection(head1, head2):
    # 创建散列表
    hash_table = {}
    current_node = head1

    # 循环第一个链表，将元素值存储到散列表中
    while current_node != None:
        hash_table[current_node.value] = 1
        current_node = current_node.next

    # 循环第二个链表，如果元素值在散列表中，则将该元素值存储到新链表中
    new_head = None
    current_node = head2
    while current_node != None:
        if hash_table.get(current_node.value):
            if new_head == None:
                new_head = Node(current_node.value)
                current_node = current_node.next
                continue
            new_node = Node(current_node.value)
            current_new_node = new_head
            while current_new_node.next != None:
                current_new_node = current_new_node.next
            current_new_node.next = new_node
        current_node = current_node.next

    return new_head

以上是一个Python的实现，其中，我们同样创建了一个散列表，然后循环第一个链表，将链表中的元素值存储到散列表中。接着，我们循环第二个链表，查找该链表中的元素值是否在散列表中，如果在，则将该元素值存储到新的链表中。

代码片段

def intersection(head1, head2):
    # 创建散列表
    hash_table = {}
    current_node = head1

    # 循环第一个链表，将元素值存储到散列表中
    while current_node != None:
        hash_table[current_node.value] = 1
        current_node = current_node.next

    # 循环第二个链表，如果元素值在散列表中，则将该元素值存储到新链表中
    new_head = None
    current_node = head2
    while current_node != None:
        if hash_table.get(current_node.value):
            if new_head == None:
                new_head = Node(current_node.value)
                current_node = current_node.next
                continue
            new_node = Node(current_node.value)
            current_new_node = new_head
            while current_new_node.next != None:
                current_new_node = current_new_node.next
            current_new_node.next = new_node
        current_node = current_node.next

    return new_head

总结

通过使用散列表，我们可以将链表交集和并集的查找时间复杂度降低到$O(1)$，从而提高查找效率。在实际应用中，我们可以使用Python中的字典来实现散列表。