]编制一个能演示执行集合的并、交和差运算的程序。[基本要求]集合的元素限定为小写字母字符 [‘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`类的实例来执行这些运算。最后，创建了两个集合并将测试数据插入到集合中，然后展示了集合的元素，执行了并、交和差运算，并展示了结果。