// 集合交运算 Set intersection(Set set1, Set set2) { Set set; init(&set); Node* p = set1.head; while (p != NULL) { if (strstr(set2.head, &(p->data)) != NULL) { insert(&set, p->data); } p = p->next; } return set; } // 集合并运算 Set union_set(Set set1, Set set2) { Set set; init(&set); Node* p = set1.head; while (p != NULL) { insert(&set, p->data); p = p->next; } p = set2.head; while (p != NULL) { if (strstr(set.head, &(p->data)) == NULL) { insert(&set, p->data); } p = p->next; } return set; } // 集合差运算 Set difference(Set set1, Set set2) { Set set; init(&set); Node* p = set1.head; while (p != NULL) { if (strstr(set2.head, &(p->data)) == NULL) { insert(&set, p->data); } p = p->next; } return set; }

这段代码实现了集合的交、并、差等运算。其中交运算（intersection）遍历集合1中的所有元素，如果该元素也在集合2中则将其加入到新集合中。并运算（union_set）先将集合1中的所有元素加入到新集合中，再遍历集合2中的所有元素，如果该元素不在新集合中则将其加入到新集合中。差运算（difference）遍历集合1中的所有元素，如果该元素不在集合2中则将其加入到新集合中。这些运算都使用了集合的初始化、插入元素等基本操作来构造新的集合。需要注意的是在判断字符在集合中是否存在时使用了 strstr 函数，该函数常用于判断字符串中是否包含指定字符串。在这里可以用来判断字符是否在集合中。

相关问题

]编制一个能演示执行集合的并、交和差运算的程序。[基本要求]集合的元素限定为小写字母字符 [‘a’..’z’]，使用链表完成。[测试数据]（1）输入：set1=\"magazine\"，set2=\"pap

### 回答1：
er\"，输出：并集为：aegimnpz，交集为：ae，差集为：gimnz。

（2）输入：set1=\"hello\"，set2=\"world\"，输出：并集为：dehlorw，交集为：lo，差集为：eh。

### 回答2：
下面是一个能够演示执行集合并、交和差运算的程序，其集合的元素限定为小写字母字符[a..z]，使用链表完成。

# 创建链表节点类
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

# 创建集合类
class Set:
    def __init__(self):
        self.head = None

    # 向集合中添加元素
    def add(self, data):
        node = Node(data)
        if self.head is None:
            self.head = node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = node

    # 遍历并输出集合的元素
    def display(self):
        current = self.head
        while current:
            print(current.data, end = " ")
            current = current.next
        print("")

    # 集合并运算
    def union(self, other_set):
        new_set = Set()
        current = self.head
        while current:
            new_set.add(current.data)
            current = current.next

        current = other_set.head
        while current:
            if not self.contains(current.data):
                new_set.add(current.data)
            current = current.next

        return new_set

    # 集合交运算
    def intersection(self, other_set):
        new_set = Set()
        current = self.head
        while current:
            if other_set.contains(current.data):
                new_set.add(current.data)
            current = current.next

        return new_set

    # 集合差运算
    def difference(self, other_set):
        new_set = Set()
        current = self.head
        while current:
            if not other_set.contains(current.data):
                new_set.add(current.data)
            current = current.next

        return new_set

    # 判断集合中是否包含某个元素
    def contains(self, element):
        current = self.head
        while current:
            if current.data == element:
                return True
            current = current.next
        return False

# 测试数据
set1 = Set()
set1.add('m')
set1.add('a')
set1.add('g')
set1.add('a')
set1.add('z')
set1.add('i')
set1.add('n')
set1.add('e')

set2 = Set()
set2.add('p')
set2.add('a')
set2.add('p')

# 执行集合并运算
union_set = set1.union(set2)
print("集合并运算结果：")
union_set.display()

# 执行集合交运算
intersection_set = set1.intersection(set2)
print("集合交运算结果：")
intersection_set.display()

# 执行集合差运算
difference_set = set1.difference(set2)
print("集合差运算结果：")
difference_set.display()

希望对你有帮助！

### 回答3：
下面是一个能够演示执行并、交和差运算的程序：

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

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

    def insert(self, value):
        if self.head is None:
            self.head = Node(value)
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = Node(value)

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

def union(set1, set2):
    union_set = Set()
    current = set1.head
    while current:
        union_set.insert(current.value)
        current = current.next

    current = set2.head
    while current:
        if not is_present(union_set, current.value):
            union_set.insert(current.value)
        current = current.next
        
    return union_set

def intersection(set1, set2):
    intersection_set = Set()
    current = set1.head
    while current:
        if is_present(set2, current.value):
            intersection_set.insert(current.value)
        current = current.next

    return intersection_set

def difference(set1, set2):
    difference_set = Set()
    current = set1.head
    while current:
        if not is_present(set2, current.value):
            difference_set.insert(current.value)
        current = current.next

    return difference_set

def is_present(set, value):
    current = set.head
    while current:
        if current.value == value:
            return True
        current = current.next
    return False

set1 = Set()
set2 = Set()

set1_string = "magazine"
set2_string = "pap"

for char in set1_string:
    set1.insert(char)

for char in set2_string:
    set2.insert(char)

print("Set1:")
set1.display()

print("Set2:")
set2.display()

print("Union:")
union_set = union(set1, set2)
union_set.display()

print("Intersection:")
intersection_set = intersection(set1, set2)
intersection_set.display()

print("Difference:")
difference_set = difference(set1, set2)
difference_set.display()

该程序首先定义了一个`Node`类来表示链表中的节点，然后定义了`Set`类来表示集合。`Set`类具有插入元素和展示集合元素的功能。接下来定义了并、交和差三种集合运算的函数，并使用`Set`类的实例来执行这些运算。最后，创建了两个集合并将测试数据插入到集合中，然后展示了集合的元素，执行了并、交和差运算，并展示了结果。

用有序单链表表示集合，实现集合的交、并、差运算

以下是用Python语言实现集合交、并、差运算的示例代码，其中假设链表中的元素为整数：

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

class Set:
    def __init__(self):
        self.head = None
    
    # 在集合中添加元素
    def add(self, val):
        if not self.contains(val):
            new_node = Node(val)
            new_node.next = self.head
            self.head = new_node
    
    # 判断集合中是否包含某个元素
    def contains(self, val):
        curr = self.head
        while curr:
            if curr.val == val:
                return True
            curr = curr.next
        return False
    
    # 集合的交运算
    def intersection(self, other):
        result = Set()
        curr = self.head
        while curr:
            if other.contains(curr.val):
                result.add(curr.val)
            curr = curr.next
        return result
    
    # 集合的并运算
    def union(self, other):
        result = Set()
        curr = self.head
        while curr:
            result.add(curr.val)
            curr = curr.next
        curr = other.head
        while curr:
            result.add(curr.val)
            curr = curr.next
        return result
    
    # 集合的差运算
    def difference(self, other):
        result = Set()
        curr = self.head
        while curr:
            if not other.contains(curr.val):
                result.add(curr.val)
            curr = curr.next
        return result

使用示例：

# 创建两个集合
set1 = Set()
set2 = Set()

# 添加元素
set1.add(1)
set1.add(2)
set1.add(3)
set2.add(3)
set2.add(4)
set2.add(5)

# 集合的交运算
result = set1.intersection(set2)
curr = result.head
while curr:
    print(curr.val)
    curr = curr.next
# 输出：3

# 集合的并运算
result = set1.union(set2)
curr = result.head
while curr:
    print(curr.val)
    curr = curr.next
# 输出：1 2 3 4 5

# 集合的差运算
result = set1.difference(set2)
curr = result.head
while curr:
    print(curr.val)
    curr = curr.next
# 输出：1 2