写一个用链表和c语言写的计算集合的交集、并集、差集和补集的代码

以下是一个用链表和 C 语言实现计算集合的交集、并集、差集和补集的代码：

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

// 定义链表结点
typedef struct Node {
    int value;
    struct Node *next;
} Node;

// 定义链表头结点
typedef struct {
    Node *head;
    Node *tail;
} List;

// 初始化链表
void initList(List *list) {
    list->head = NULL;
    list->tail = NULL;
}

// 在链表尾部插入一个新结点
void insert(List *list, int value) {
    Node *newNode = (Node *) malloc(sizeof(Node));
    newNode->value = value;
    newNode->next = NULL;

    if (list->head == NULL) {
        list->head = newNode;
    } else {
        list->tail->next = newNode;
    }
    list->tail = newNode;
}

// 判断链表中是否存在某个元素
int find(List *list, int value) {
    Node *p = list->head;
    while (p != NULL) {
        if (p->value == value) {
            return 1;
        }
        p = p->next;
    }
    return 0;
}

// 链表的交集运算
List intersection(List *list1, List *list2) {
    List result;
    initList(&result);

    Node *p1 = list1->head;
    while (p1 != NULL) {
        if (find(list2, p1->value)) {
            insert(&result, p1->value);
        }
        p1 = p1->next;
    }

    return result;
}

// 链表的并集运算
List unionSet(List *list1, List *list2) {
    List result;
    initList(&result);

    Node *p1 = list1->head;
    while (p1 != NULL) {
        insert(&result, p1->value);
        p1 = p1->next;
    }

    Node *p2 = list2->head;
    while (p2 != NULL) {
        if (!find(&result, p2->value)) {
            insert(&result, p2->value);
        }
        p2 = p2->next;
    }

    return result;
}

// 链表的差集运算
List difference(List *list1, List *list2) {
    List result;
    initList(&result);

    Node *p1 = list1->head;
    while (p1 != NULL) {
        if (!find(list2, p1->value)) {
            insert(&result, p1->value);
        }
        p1 = p1->next;
    }

    return result;
}

// 链表的补集运算
List complement(List *list1, List *list2) {
    List result;
    initList(&result);

    Node *p1 = list1->head;
    while (p1 != NULL) {
        if (!find(list2, p1->value)) {
            insert(&result, p1->value);
        }
        p1 = p1->next;
    }

    Node *p2 = list2->head;
    while (p2 != NULL) {
        if (!find(list1, p2->value)) {
            insert(&result, p2->value);
        }
        p2 = p2->next;
    }

    return result;
}

// 打印链表中的元素
void printList(List *list) {
    Node *p = list->head;
    while (p != NULL) {
        printf("%d ", p->value);
        p = p->next;
    }
    printf("\n");
}

int main() {
    List list1, list2;
    initList(&list1);
    initList(&list2);

    insert(&list1, 1);
    insert(&list1, 2);
    insert(&list1, 3);

    insert(&list2, 2);
    insert(&list2, 3);
    insert(&list2, 4);

    printf("List 1: ");
    printList(&list1);
    printf("List 2: ");
    printList(&list2);

    printf("Intersection: ");
    List result1 = intersection(&list1, &list2);
    printList(&result1);

    printf("Union: ");
    List result2 = unionSet(&list1, &list2);
    printList(&result2);

    printf("Difference (list1 - list2): ");
    List result3 = difference(&list1, &list2);
    printList(&result3);

    printf("Complement: ");
    List result4 = complement(&list1, &list2);
    printList(&result4);

    return 0;
}

在上述代码中，我们定义了链表结点类型 `Node` 和链表类型 `List`，其中 `List` 包含链表头结点和尾结点。我们使用 `initList` 函数初始化链表，使用 `insert` 函数在链表尾部插入一个新结点。`find` 函数用于判断链表中是否存在某个元素。

我们实现了四个函数：`intersection`、`unionSet`、`difference` 和 `complement`，分别用于计算集合的交集、并集、差集和补集。这些函数都返回一个链表类型的结果。最后，我们使用 `printList` 函数打印链表中的元素。