C语言数据结构单链表编写一个程序求两个集合的并、交、差

在C语言中，我们可以使用链表来表示集合的数据结构。这里我们将创建三个链表分别表示两个集合A和B，并实现并集、交集和差集的操作。首先，我们需要定义节点结构体和一些辅助函数。

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 创建新节点
Node* createNode(int value) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode != NULL) {
        newNode->data = value;
        newNode->next = NULL;
    }
    return newNode;
}

// 添加元素到链表
void addElement(Node** head, int value) {
    Node* newNode = createNode(value);
    if (*head == NULL) {
        *head = newNode;
    } else {
        Node* temp = *head;
        while (temp->next != NULL) {
            temp = temp->next;
        }
        temp->next = newNode;
    }
}

// 打印链表
void printList(Node* head) {
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

// 并集操作：将两个集合的所有元素添加到新的链表中
Node* unionSet(Node* listA, Node* listB) {
    // 新建一个空链表存储结果
    Node* resultHead = NULL;
    
    // 遍历两个链表并添加所有元素
    for (; listA != NULL || listB != NULL; ) {
        if (listA == NULL) {
            addElement(&resultHead, listB->data);
            listB = listB->next;
        } else if (listB == NULL) {
            addElement(&resultHead, listA->data);
            listA = listA->next;
        } else if (listA->data <= listB->data) {
            addElement(&resultHead, listA->data);
            listA = listA->next;
        } else {
            addElement(&resultHead, listB->data);
            listB = listB->next;
        }
    }
    
    return resultHead;
}

// 交集操作：找出同时存在于两个集合中的元素
Node* intersectionSet(Node* listA, Node* listB) {
    Node* intersectionHead = NULL;
    Node* tempA = listA;
    Node* tempB = listB;
    
    while (tempA && tempB) {
        if (tempA->data == tempB->data) {
            addElement(&intersectionHead, tempA->data);
            tempA = tempA->next;
            tempB = tempB->next;
        } else if (tempA->data < tempB->data) {
            tempA = tempA->next;
        } else {
            tempB = tempB->next;
        }
    }

    return intersectionHead;
}

// 差集操作：找出仅出现在第一个集合中的元素
Node* differenceSet(Node* listA, Node* listB) {
    Node* tempA = listA;
    Node* tempB = listB;
    Node* diffResultHead = NULL;
    
    while (tempA) {
        bool found = NO;
        while (tempB) {
            if (tempA->data == tempB->data) {
                found = YES;
                break;
            }
            tempB = tempB->next;
        }
        
        if (!found) {
            addElement(&diffResultHead, tempA->data);
        }
        tempA = tempA->next;
    }
    
    return diffResultHead;
}

int main() {
    // 示例用法
    Node* listA = NULL;
    Node* listB = NULL;

    addElement(&listA, 1);
    addElement(&listA, 2);
    addElement(&listA, 3);
    addElement(&listB, 2);
    addElement(&listB, 4);

    Node* unionList = unionSet(listA, listB);
    printList(unionList); // 输出: 1 2 3 4

    Node* intersectList = intersectionSet(listA, listB);
    printList(intersectList); // 输出: 2

    Node* differList = differenceSet(listA, listB);
    printList(differList); // 输出: 1 3

    return 0;
}

在这个示例中，我们首先定义了链表节点和几个用于操作的函数。然后在`main()`函数中创建了两个集合的列表，并展示了如何通过`unionSet()`、`intersectionSet()`和`differenceSet()`计算它们的并集、交集和差集。