LinkList DifferenceList(LinkList L1, LinkList L2) { //求出差集 A-B(除去集合A和集合B相同的元素,剩下A的集合元素) LinkList s1,s2,p,q,s; Init(&s); s1 = L1; //A的集合 L1 s2 = Intersection(L1,L2,0); //交集 p=s1->next; //利用p指向集合A这个表 while(p) { q=s2->next; while(q) { //遍历交集 if(strcmp(p->data,q->data)!=0) { //当s2与s1中没有相同的元素时,取出不相同的元素,有相同的即结束 q=q->next; } else { break; } } if(!q) { //将取出的元素放入到链表s中 LinkList inter = (LinkList)malloc(sizeof(LLinkList));//头插法插入 strcpy(inter->data,p->data); inter->next = s->next; s->next = inter; } p=p->next; } Output(s); return s; }
时间: 2024-04-23 09:24:46 浏览: 13
这是一段 C 语言代码,实现了求 LinkList 类型的差集操作,即将集合 A 中与集合 B 相同的元素去除,得到剩下的元素集合。具体实现过程如下:
1. 定义 LinkList 类型的指针变量 s1、s2、p、q、s,其中 s1 指向集合 A,s2 指向集合 A 和集合 B 的交集,p 和 q 分别用于遍历集合 A 和交集 s2,s 用于存储 A-B 的结果。
2. 利用 Init 函数初始化链表 s。
3. 遍历集合 A,对于每一个元素,遍历交集 s2,若找到与之相同的元素,则退出内层循环,否则将该元素加入链表 s 中。
4. 返回链表 s,即为 A-B 的结果。
需要注意的是,该代码中的 Intersection 函数用于求 A 和 B 的交集,第三个参数为 0 表示不保留重复元素。此外,该代码中使用了头插法将元素加入链表 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中的元素非递减排列,要求合并后的单链表中元素也按值非递减排列。
好的,根据你的补充,我来给出完整的代码实现:
```c++
#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` 遍历合并后的链表,并输出每个节点的值。
希望这段代码能够帮助到你,如果你还有其他问题,可以随时问我。