LinkList Union(LinkList L1,LinkList L2,int i) { //新建一个链表,用来存储集合A和集合B相并后的元素 LinkList s; Init(&s); //初始化 LinkList p1,p2; p1=L1->next; //指向集合A p2=L2->next; //指向集合B while(p1) { //遍历集合A，将集合A中的元素存储到新建的链表中去 LinkList inter = (LinkList)malloc(sizeof(LLinkList));//头插法插入 strcpy(inter->data,p1->data); inter->next = s->next; s->next = inter; p1 = p1->next; } while(p2) { //遍历集合B， p1 = s->next; //p1指向新建的链表 while(p1) { if(strcmp(p1->data,p2->data)!=0) { //当有不相同的元素时，则指向下一结点，否则结束 p1 = p1->next; } else { break; } } if(!p1) { //将集合B中的元素放到链表s中去 LinkList inter = (LinkList)malloc(sizeof(LLinkList));//头插法插入 strcpy(inter->data,p2->data); inter->next = s->next; s->next = inter; } p2 = p2->next; } if(i) Output(s); return s; }

这是一个函数，其功能是求两个链表的并集，其中采用了头插法和双重循环来实现。具体实现过程如下：

1. 定义了一个指针变量 s，用来表示新建的存储并集的链表，并对其进行初始化。

2. 定义了两个指针变量 p1 和 p2，分别指向链表 L1 和 L2 的第一个节点。

3. 开始第一层循环，其中循环条件是 p1 不为空，即遍历链表 L1。

4. 在第一层循环中，将 p1 的数据插入到新建的链表 s 中。

5. 插入节点的方式是先动态分配内存空间，然后将该节点的数据域赋值为 p1 的数据，将该节点的 next 指针指向 s 的下一个节点，最后将 s 的 next 指针指向该节点。

6. 第一层循环结束后，开始第二层循环，其中循环条件是 p2 不为空，即遍历链表 L2。

7. 在第二层循环中，遍历新建的链表 s，判断当前节点的数据是否与 p2 的数据相同，若相同则跳出循环，否则继续向后遍历。

8. 若遍历完整个链表 s 后仍未找到相同的节点，则将 p2 的数据插入到链表 s 中。

9. 插入节点的方式同上面的步骤 5。

10. 第二层循环结束后，将 p2 指向下一个节点，继续下一轮循环，直至遍历完链表 L2。

11. 若参数 i 不为 0，则输出新建的链表 s。

12. 函数结束，返回链表头指针 s。

相关问题

LinkList Intersection(LinkList L1, LinkList L2,int i) { //新建一个链表，用来存储两个集合的交集 LinkList s; Init(&s); //初始化链表 LinkList Lp,Lq; Lp=L1->next; //指向A集合的结点 while(Lp) { //遍历集合A Lq = L2->next; //指向B集合的结点 while(Lq) { //遍历集合B if(strcmp(Lp->data,Lq->data)==0) { //当集合A和集合B中有相同的元素时，将相同的元素存入到新建的链表中去 LinkList inter = (LinkList)malloc(sizeof(LLinkList)); //头插法插入 strcpy(inter->data,Lp->data); inter->next = s->next; s->next = inter; } Lq=Lq->next; } Lp=Lp->next; } if(i) Output(s); return s; }

这是一个函数，其功能是求两个链表的交集，其中采用了双重循环和头插法来实现。具体实现过程如下：

1. 定义了一个指针变量 s，用来表示新建的存储交集的链表，并对其进行初始化。

2. 定义了两个指针变量 Lp 和 Lq，分别指向链表 L1 和 L2 的第一个节点。

3. 开始第一层循环，其中循环条件是 Lp 不为空，即遍历链表 L1。

4. 在第一层循环中，开始第二层循环，其中循环条件是 Lq 不为空，即遍历链表 L2。

5. 在第二层循环中，判断 Lp 的数据是否与 Lq 的数据相同，若相同则将该节点插入到新建的链表 s 中。

6. 插入节点的方式是先动态分配内存空间，然后将该节点的数据域赋值为 Lp 的数据，将该节点的 next 指针指向 s 的下一个节点，最后将 s 的 next 指针指向该节点。

7. 第二层循环结束后，将 Lq 指向下一个节点，继续第一层循环，直至遍历完链表 L2。

8. 第一层循环结束后，将 Lp 指向下一个节点，继续下一轮循环，直至遍历完链表 L1。

9. 若参数 i 不为 0，则输出新建的链表 s。

10. 函数结束，返回链表头指针 s。

LinkList Read( ); //按顺序依次读入元素，生成一个带头结点的单链表，表中元素值排列顺序与输入顺序一致，若输入-1，则创建链表结束（链表中不包含-1）。此处要求元素值按非递减顺序录入 LinkList Merge( LinkList L1, LinkList L2 ); //合并L1与L2。已知L1与L2中的元素非递减排列，要求合并后的单链表中元素也按值非递减排列。

好的，根据你的补充，我来给出完整的代码实现：

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

typedef int ElemType;

typedef struct Node {
    ElemType data;
    struct Node *next;
} LNode, *LinkList;

LinkList Read() {
    LinkList head = (LinkList) malloc(sizeof(LNode));
    head->next = NULL;
    LNode *tail = head;
    int num;
    while (scanf("%d", &num) == 1 && num != -1) {
        LNode *p = (LNode*)malloc(sizeof(LNode));
        p->data = num;
        p->next = NULL;
        tail->next = p;
        tail = p;
    }
    return head;
}

LinkList Merge(LinkList L1, LinkList L2) {
    LinkList head = (LinkList) malloc(sizeof(LNode));
    head->next = NULL;
    LNode *tail = head;
    LNode *p1 = L1->next, *p2 = L2->next;
    while (p1 && p2) {
        if (p1->data <= p2->data) {
            tail->next = p1;
            tail = p1;
            p1 = p1->next;
        } else {
            tail->next = p2;
            tail = p2;
            p2 = p2->next;
        }
    }
    if (p1) {
        tail->next = p1;
    }
    if (p2) {
        tail->next = p2;
    }
    return head;
}

int main() {
    LinkList L1, L2, L;
    L1 = Read();
    L2 = Read();
    L = Merge(L1, L2);
    LNode *p = L->next;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }
    return 0;
}

这个程序中，我们首先定义了一个单链表结构体 `LNode`，包含了节点的值和下一个节点的指针。然后，我们实现了两个函数：`Read` 和 `Merge`。

`Read` 函数按顺序依次读入元素，生成一个带头结点的单链表，表中元素值排列顺序与输入顺序一致，若输入 `-1`，则创建链表结束（链表中不包含 `-1`）。具体地，我们首先为头结点分配内存空间，然后使用一个尾指针 `tail` 指向链表的最后一个节点，逐个读入元素，为每个元素创建新节点，并把新节点插入到链表的尾部。

`Merge` 函数合并 `L1` 与 `L2`。已知 `L1` 与 `L2` 中的元素非递减排列，要求合并后的单链表中元素也按值非递减排列。具体地，我们创建一个新的链表 `head`，并使用一个尾指针 `tail` 指向链表的最后一个节点。然后，我们使用两个指针 `p1` 和 `p2` 分别指向 `L1` 和 `L2` 中的第一个节点，依次比较两个指针所指向的节点的值，将较小的节点插入到 `head` 的尾部，并将对应指针向后移动。直到其中一个指针为空，我们将另一个指针剩余的节点依次插入到 `head` 的尾部。最后，我们返回 `head`。

在 `main` 函数中，我们首先调用 `Read` 函数分别读入两个链表 `L1` 和 `L2`。然后，我们调用 `Merge` 函数将两个链表合并，并使用一个指针 `p` 遍历合并后的链表，并输出每个节点的值。

希望这段代码能够帮助到你，如果你还有其他问题，可以随时问我。