用c语言的链表实现集合的交，并，差运算

在 C 语言中，我们可以使用链表来实现集合的运算。下面是一个基本的链表结构体定义：

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

typedef struct List {
    Node *head;
    int size;
} List;

其中，`Node` 结构体表示链表中的单个节点，包含一个整数类型的数据和一个指向下一个节点的指针；`List` 结构体表示整个链表，包含一个指向头节点的指针和链表的大小。

接下来，我们可以定义一些集合的基本运算，比如并集、交集和差集：

List union_set(List l1, List l2) {
    List result = { NULL, 0 };
    Node *p1 = l1.head;
    Node *p2 = l2.head;

    // 创建一个新的链表，用于存储两个集合的所有元素
    List temp = { NULL, 0 };

    while (p1 != NULL || p2 != NULL) {
        if (p1 == NULL) {
            // l1 遍历完了，将 l2 中剩余的元素添加到 temp 中
            temp = append(temp, p2->data);
            p2 = p2->next;
        } else if (p2 == NULL) {
            // l2 遍历完了，将 l1 中剩余的元素添加到 temp 中
            temp = append(temp, p1->data);
            p1 = p1->next;
        } else if (p1->data < p2->data) {
            // 将 l1 中的元素添加到 temp 中
            temp = append(temp, p1->data);
            p1 = p1->next;
        } else if (p1->data > p2->data) {
            // 将 l2 中的元素添加到 temp 中
            temp = append(temp, p2->data);
            p2 = p2->next;
        } else {
            // 两个集合都包含该元素，将该元素添加到 temp 中
            temp = append(temp, p1->data);
            p1 = p1->next;
            p2 = p2->next;
        }
    }

    // 更新 result 结构体
    result.head = temp.head;
    result.size = temp.size;

    return result;
}

List intersection_set(List l1, List l2) {
    List result = { NULL, 0 };
    Node *p1 = l1.head;
    Node *p2 = l2.head;

    // 创建一个新的链表，用于存储两个集合的交集元素
    List temp = { NULL, 0 };

    while (p1 != NULL && p2 != NULL) {
        if (p1->data < p2->data) {
            p1 = p1->next;
        } else if (p1->data > p2->data) {
            p2 = p2->next;
        } else {
            // 两个集合都包含该元素，将该元素添加到 temp 中
            temp = append(temp, p1->data);
            p1 = p1->next;
            p2 = p2->next;
        }
    }

    // 更新 result 结构体
    result.head = temp.head;
    result.size = temp.size;

    return result;
}

List difference_set(List l1, List l2) {
    List result = { NULL, 0 };
    Node *p1 = l1.head;
    Node *p2 = l2.head;

    // 创建一个新的链表，用于存储两个集合的差集元素
    List temp = { NULL, 0 };

    while (p1 != NULL && p2 != NULL) {
        if (p1->data < p2->data) {
            // l2 中不包含该元素，将该元素添加到 temp 中
            temp = append(temp, p1->data);
            p1 = p1->next;
        } else if (p1->data > p2->data) {
            p2 = p2->next;
        } else {
            // 两个集合都包含该元素，不添加到 temp 中
            p1 = p1->next;
            p2 = p2->next;
        }
    }

    // 将 l1 中剩余的元素添加到 temp 中
    while (p1 != NULL) {
        temp = append(temp, p1->data);
        p1 = p1->next;
    }

    // 更新 result 结构体
    result.head = temp.head;
    result.size = temp.size;

    return result;
}

需要注意的是，这里假设两个集合已经按照从小到大的顺序排好序了。如果集合中的元素是无序的，我们需要在运算前先将其排序。此外，在实现中还需要注意内存管理，比如在使用 `malloc` 函数分配新节点内存后，需要在函数返回前释放相关的内存。

以上就是一个基本的链表实现集合运算的例子，可以根据实际需求进行扩展和优化。