用c语言编写一个能通过静态链表实现集合并集的程序

以下是一个使用静态链表实现集合并集的c程序：

#include <stdio.h>

#define MAX_SIZE 100

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

Node list[MAX_SIZE];
int head1, head2, head3;

// 初始化链表
void initList() {
    int i;
    for (i = 0; i < MAX_SIZE - 1; i++) {
        list[i].next = i + 1;
    }
    list[MAX_SIZE - 1].next = -1;
}

// 插入元素
int insert(Node list[], int head, int data) {
    int p = head;
    int q = list[head].next;

    while (q != -1 && list[q].data < data) {
        p = q;
        q = list[q].next;
    }

    int newNode = list[0].next;
    if (newNode != -1) {
        list[0].next = list[newNode].next;
        list[newNode].data = data;
        list[newNode].next = q;
        list[p].next = newNode;
        return 1;
    }

    return 0;
}

// 遍历链表
void traverse(Node list[], int head) {
    int p = list[head].next;
    while (p != -1) {
        printf("%d ", list[p].data);
        p = list[p].next;
    }
    printf("\n");
}

// 集合并集
void unionSet(Node list[], int head1, int head2, int head3) {
    int p = list[head1].next;
    while (p != -1) {
        insert(list, head3, list[p].data);
        p = list[p].next;
    }

    p = list[head2].next;
    while (p != -1) {
        if (!insert(list, head3, list[p].data)) {
            return;
        }
        p = list[p].next;
    }
}

int main() {
    initList();

    // 创建集合1
    head1 = list[0].next;
    list[head1].next = -1;
    insert(list, head1, 1);
    insert(list, head1, 3);
    insert(list, head1, 5);
    insert(list, head1, 7);
    printf("集合1：");
    traverse(list, head1);

    // 创建集合2
    head2 = list[0].next;
    list[head2].next = -1;
    insert(list, head2, 2);
    insert(list, head2, 4);
    insert(list, head2, 5);
    insert(list, head2, 8);
    printf("集合2：");
    traverse(list, head2);

    // 创建集合3并求并集
    head3 = list[0].next;
    list[head3].next = -1;
    printf("集合3：");
    unionSet(list, head1, head2, head3);
    traverse(list, head3);

    return 0;
}

代码解析：

- 定义了一个静态链表结构体Node，其中包含了数据data和指向下一个节点的next。
- 定义了一个全局的list数组，用于存放静态链表的节点，以及三个头节点head1、head2、head3。
- 初始化链表时，将每个节点的next指向下一个节点。
- 插入元素时，采用类似于链表的方法，从头节点开始遍历，找到第一个比插入元素大的节点的前一个节点，然后将新节点插入到该节点和下一个节点之间。
- 遍历链表时，从头节点的下一个节点开始遍历，依次输出每个节点的数据。
- 集合并集时，首先遍历集合1的所有节点，并将它们插入到集合3中。然后遍历集合2的所有节点，如果在集合3中找到了相同的元素则跳过，否则将该元素插入到集合3中。

运行结果：

集合1：1 3 5 7 
集合2：2 4 5 8 
集合3：1 2 3 4 5 7 8