写一份能体现数据结构的实现集合的交并差补运算的代码，要求用c语言实现

以下是一份用 C 语言实现集合交并差补运算的代码，其中利用了链表数据结构来存储集合元素：

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

typedef struct node {
    int data;
    struct node *next;
} Node;

// 创建链表
Node *createList() {
    Node *head = (Node *) malloc(sizeof(Node));
    head->next = NULL;
    return head;
}

// 向链表中添加元素
void addElement(Node *head, int data) {
    Node *newNode = (Node *) malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    Node *p = head;
    while (p->next != NULL) {
        p = p->next;
    }
    p->next = newNode;
}

// 从链表中删除元素
void deleteElement(Node *head, int data) {
    Node *p = head->next;
    Node *pre = head;
    while (p != NULL) {
        if (p->data == data) {
            pre->next = p->next;
            free(p);
            break;
        }
        pre = p;
        p = p->next;
    }
}

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

// 计算集合交集
Node *intersection(Node *set1, Node *set2) {
    Node *result = createList();
    Node *p = set1->next;
    while (p != NULL) {
        if (contains(set2, p->data)) {
            addElement(result, p->data);
        }
        p = p->next;
    }
    return result;
}

// 计算集合并集
Node *unionSet(Node *set1, Node *set2) {
    Node *result = createList();
    Node *p = set1->next;
    while (p != NULL) {
        addElement(result, p->data);
        p = p->next;
    }
    p = set2->next;
    while (p != NULL) {
        if (!contains(result, p->data)) {
            addElement(result, p->data);
        }
        p = p->next;
    }
    return result;
}

// 计算集合差集
Node *difference(Node *set1, Node *set2) {
    Node *result = createList();
    Node *p = set1->next;
    while (p != NULL) {
        if (!contains(set2, p->data)) {
            addElement(result, p->data);
        }
        p = p->next;
    }
    return result;
}

// 计算集合补集
Node *complement(Node *set) {
    Node *result = createList();
    int i;
    for (i = 0; i < 100; i++) {  // 假设集合元素的范围是 [0, 99]
        if (!contains(set, i)) {
            addElement(result, i);
        }
    }
    return result;
}

// 判断链表中是否包含某个元素
int contains(Node *head, int data) {
    Node *p = head->next;
    while (p != NULL) {
        if (p->data == data) {
            return 1;
        }
        p = p->next;
    }
    return 0;
}

int main() {
    Node *set1 = createList();
    addElement(set1, 1);
    addElement(set1, 2);
    addElement(set1, 3);
    addElement(set1, 4);

    Node *set2 = createList();
    addElement(set2, 3);
    addElement(set2, 4);
    addElement(set2, 5);
    addElement(set2, 6);

    printf("Set1: ");
    printList(set1);
    printf("Set2: ");
    printList(set2);

    printf("Intersection: ");
    Node *inter = intersection(set1, set2);
    printList(inter);

    printf("Union: ");
    Node *un = unionSet(set1, set2);
    printList(un);

    printf("Difference set1 - set2: ");
    Node *diff1 = difference(set1, set2);
    printList(diff1);

    printf("Difference set2 - set1: ");
    Node *diff2 = difference(set2, set1);
    printList(diff2);

    printf("Complement of set1: ");
    Node *comp = complement(set1);
    printList(comp);

    return 0;
}

这份代码中，我们定义了一个 `Node` 结构体，表示链表中的一个节点。`Node` 结构体中包含一个整型成员 `data`，表示节点中存储的数据，以及一个指向下一个节点的指针成员 `next`。

然后，我们定义了一些函数来操作链表，包括创建链表、向链表中添加元素、从链表中删除元素、打印链表中的元素、判断链表中是否包含某个元素等。在计算集合交并差补运算时，我们利用这些函数来操作链表。

具体来说，我们定义了以下几个函数来计算集合交并差补运算：

- `intersection` 函数：计算集合交集，返回一个新的链表。
- `unionSet` 函数：计算集合并集，返回一个新的链表。
- `difference` 函数：计算集合差集，返回一个新的链表。
- `complement` 函数：计算集合补集，返回一个新的链表。

最后，在 `main` 函数中，我们定义了两个集合 `set1` 和 `set2`，并对它们进行了交、并、差、补等运算，并打印了结果。