使用单链表实现集合操作：并集、交集与差集

✅作者简介：2022年博客新星 第八。热爱国学的Java后端开发者，修心和技术同步精进。

🍎个人主页：Java Fans的博客

🍊个人信条：不迁怒，不贰过。小知识，大智慧。

💞当前专栏：Java案例分享专栏

✨特色专栏：国学周更-心性养成之路

🥭本文内容：使用单链表实现集合操作：并集、交集与差集

 

前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。

文章目录

• 前言
• • [1. 什么是集合？](#1. 什么是集合？)
  • [2. 单链表的基本概念](#2. 单链表的基本概念)
  • [3. 实现集合操作的单链表](#3. 实现集合操作的单链表)
  • • [3.1 节点类与链表类](#3.1 节点类与链表类)
    • [3.2 插入元素](#3.2 插入元素)
    • [3.3 显示元素](#3.3 显示元素)
    • [3.4 集合操作](#3.4 集合操作)
    • • [3.4.1 并集](#3.4.1 并集)
      • [3.4.2 交集](#3.4.2 交集)
      • [3.4.3 差集](#3.4.3 差集)
  • [4. 主程序](#4. 主程序)
  • • [4.1 代码说明](#4.1 代码说明)
    • [4.2 使用示例](#4.2 使用示例)
• 结论
• 投票

前言

  在计算机科学的领域中，数据结构是构建高效算法的基石。集合作为一种基本的数据结构，广泛应用于各种场景，如数据库查询、图形处理和数据分析等。集合的操作，如并集、交集和差集，不仅是理论上的重要概念，也是实际编程中常见的需求。

  在众多数据结构中，单链表因其动态内存分配和灵活的插入与删除操作而备受青睐。通过单链表实现集合操作，可以有效地管理元素，并确保集合的唯一性和有序性。

  本文将深入探讨如何使用单链表来表示集合，并实现其基本操作。我们将通过 Python 代码示例，逐步展示如何构建一个功能齐全的集合类，帮助读者更好地理解数据结构的应用与实现。无论你是数据结构的初学者还是有一定基础的开发者，希望这篇文章能为你提供有价值的见解和实践经验。

1. 什么是集合？

  集合是一种无序且不重复的数据集合。在计算机科学中，集合通常用于表示一组唯一的元素。常见的集合操作包括：

• 并集：两个集合的并集是包含所有元素的集合。
• 交集：两个集合的交集是包含两个集合中共同元素的集合。
• 差集：两个集合的差集是包含在第一个集合中但不在第二个集合中的元素的集合。

2. 单链表的基本概念

  单链表是一种基本的数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。单链表的优点在于动态内存分配和灵活的插入与删除操作。

3. 实现集合操作的单链表

3.1 节点类与链表类

  我们首先定义一个节点类 Node 和一个链表类 LinkedList。节点类用于表示集合中的元素，而链表类则用于管理这些节点。

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

class LinkedList:
    def __init__(self):
        self.head = None

3.2 插入元素

  我们需要一个方法来按递增顺序插入元素，并确保集合中不包含重复元素。

def insert_sorted(self, data):
    new_node = Node(data)
    if self.head is None or self.head.data > data:
        new_node.next = self.head
        self.head = new_node
    else:
        current = self.head
        while current.next is not None and current.next.data < data:
            current = current.next
        if current.next is None or current.next.data != data:  # Avoid duplicates
            new_node.next = current.next
            current.next = new_node

3.3 显示元素

  为了查看集合中的元素，我们实现一个显示方法。

def display(self):
    current = self.head
    elements = []
    while current:
        elements.append(current.data)
        current = current.next
    return elements

3.4 集合操作

  接下来，我们实现并集、交集和差集的方法。

3.4.1 并集

def union(self, other):
    result = LinkedList()
    current1 = self.head
    current2 = other.head

    while current1 is not None and current2 is not None:
        if current1.data < current2.data:
            result.insert_sorted(current1.data)
            current1 = current1.next
        elif current1.data > current2.data:
            result.insert_sorted(current2.data)
            current2 = current2.next
        else:
            result.insert_sorted(current1.data)
            current1 = current1.next
            current2 = current2.next

    while current1 is not None:
        result.insert_sorted(current1.data)
        current1 = current1.next

    while current2 is not None:
        result.insert_sorted(current2.data)
        current2 = current2.next

    return result

3.4.2 交集

def intersection(self, other):
    result = LinkedList()
    current1 = self.head
    current2 = other.head

    while current1 is not None and current2 is not None:
        if current1.data < current2.data:
            current1 = current1.next
        elif current1.data > current2.data:
            current2 = current2.next
        else:
            result.insert_sorted(current1.data)
            current1 = current1.next
            current2 = current2.next

    return result

3.4.3 差集

def difference(self, other):
    result = LinkedList()
    current1 = self.head
    current2 = other.head

    while current1 is not None:
        while current2 is not None and current2.data < current1.data:
            current2 = current2.next
        if current2 is None or current2.data > current1.data:
            result.insert_sorted(current1.data)
        current1 = current1.next

    return result

4. 主程序

最后，我们编写主程序来输入两个集合并计算它们的并、交、差。

def main():
    set1 = LinkedList()
    set2 = LinkedList()

    # 输入第一个集合
    print("输入第一个集合的元素（按递增顺序，输入-1结束）：")
    while True:
        num = int(input())
        if num == -1:
            break
        set1.insert_sorted(num)

    # 输入第二个集合
    print("输入第二个集合的元素（按递增顺序，输入-1结束）：")
    while True:
        num = int(input())
        if num == -1:
            break
        set2.insert_sorted(num)

    # 计算并、交、差
    union_set = set1.union(set2)
    intersection_set = set1.intersection(set2)
    difference_set = set1.difference(set2)

    # 输出结果
    print("集合1:", set1.display())
    print("集合2:", set2.display())
    print("并集:", union_set.display())
    print("交集:", intersection_set.display())
    print("差集 (集合1 - 集合2):", difference_set.display())

if __name__ == "__main__":
    main()

4.1 代码说明

1. Node 类: 表示单链表的节点，包含数据和指向下一个节点的指针。
2. LinkedList 类 : 表示单链表，包含插入、显示、并集、交集和差集的方法。
   • insert_sorted: 按递增顺序插入元素，避免重复。
   • display: 显示链表中的元素。
   • union: 计算两个集合的并集。
   • intersection: 计算两个集合的交集。
   • difference: 计算两个集合的差集。
3. main 函数: 用于输入两个集合，调用相应的方法计算并输出结果。

4.2 使用示例

运行程序后，输入两个集合的元素（按递增顺序），输入 -1 结束输入。例如：

输入第一个集合的元素（按递增顺序，输入-1结束）：
1
3
5
7
-1
输入第二个集合的元素（按递增顺序，输入-1结束）：
3
4
5
6
-1

输出将会是：

集合1: [1, 3, 5, 7]
集合2: [3, 4, 5, 6]
并集: [1, 3, 4, 5, 6, 7]
交集: [3, 5]
差集 (集合1 - 集合2): [1, 7]

结论

  通过本文的探讨，我们深入了解了如何使用单链表来实现集合的基本操作，包括并集、交集和差集。单链表作为一种灵活的数据结构，能够有效地管理集合中的元素，确保元素的唯一性和有序性。

  我们通过 Python 代码示例，展示了如何构建一个功能齐全的集合类，涵盖了元素的插入、显示以及集合操作的实现。这不仅加深了我们对数据结构的理解，也为实际编程提供了实用的解决方案。

  在实际应用中，集合操作在数据处理、算法设计和系统优化等方面都扮演着重要角色。掌握这些基本操作将为我们在更复杂的数据结构和算法中打下坚实的基础。

  希望本文能够激发读者对数据结构的兴趣，并鼓励大家在实践中不断探索和应用这些知识。无论是在学术研究还是在实际开发中，数据结构的灵活运用都将为我们提供更高效的解决方案。

投票