求集合（用单链表表示）的并、交和差运算

最新推荐文章于 2024-08-08 09:39:18 发布
最新推荐文章于 2024-08-08 09:39:18 发布
阅读量8.7k 收藏 168
点赞数 21
文章标签： 链表 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56052256/article/details/115450138
版权

求集合（用单链表表示）的并、交和差运算

目的：掌握单链表的应用和有序单链表的二路归并算法。
内容：采用单链表表示集合（假设同一个集合中不存在重复的元素），将其按递增方式排序，构成有序单链表，并求这样的两个集合的并、交和差。

思路（并）：同时扫描两个链表，将不相同的元素放在第三个链表中。

bool Union(LinkNode* L1, LinkNode* L2, LinkNode*& L3)	//L1、L2、L3为三个单链表的头结点
{
	//如果L1和L2中均没有数据
	if (L1->next == NULL && L2->next == NULL) {
		return false;
	}
	//直到L3申请成功
	while (!L3) {
		L3 = (LinkNode*)malloc(sizeof(LNode));
	}
	LinkNode* p, * q, * r, * s = NULL;
	p = L1->next;		//p为L1的工作指针
	q = L2->next;		//q为L2的工作指针
	r = L3;				//r为L3的尾指针
	//当L1和L2均不为空时
	while (p && q) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		if (p->data < q->data) {
			s->data = p->data;	//如果此时p指向的data的值小，复制该结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			p = p->next;		//p继续向后扫描L1
		}
		else if (q->data < p->data) {
			s->data =q->data;	//如果此时q指向的data的值小，复制该结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			q = q->next;		//q继续向后扫描L2
		}
		else {
			s->data = p->data;	//如果两个值相等，复制其中一个结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			p = p->next;		//p继续向后扫描L1
			q = q->next;		//q继续向后扫描L2
		}
	}
	//当p不为空时，将剩余结点接到尾指针后面
	while (p) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		s->data = p->data;	//复制结点的值
		r->next = s;		//将s接到尾指针后面
		r = r->next;		//尾指针后移
		p = p->next;		//p继续向后扫描L1
	}
	//当q不为空时，将剩余结点接到尾指针后面
	while (q) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		s->data = q->data;	//复制结点的值
		r->next = s;		//将s接到尾指针后面
		r = r->next;		//尾指针后移
		q = q->next;		//q继续向后扫描L2
	}
	r->next = NULL;		//此时将尾指针后面置空，单链表L3建成
	return true;
}

思路（交）：同时扫描两个链表，将相同的元素放在第三个链表中。

bool Intersection(LinkNode* L1, LinkNode* L2, LinkNode*& L3)	//L1、L2、L3为三个单链表的头结点
{
	//如果L1和L2中均没有数据
	if (L1->next == NULL && L2->next == NULL) {
		return false;
	}
	//直到L3申请成功
	while (!L3) {
		L3 = (LinkNode*)malloc(sizeof(LNode));
	}
	LinkNode* p, * q, * r, * s = NULL;
	p = L1->next;		//p为L1的工作指针
	q = L2->next;		//q为L2的工作指针
	r = L3;				//r为L3的尾指针
	//当L1和L2均不为空时,只要有一个为空就不会再有交集了
	while (p && q) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		if (p->data < q->data) {
			p = p->next;		//如果p偏小，继续向后扫描L1
		}
		else if (q->data < p->data) {
			q = q->next;		//如果q偏小，继续向后扫描L2
		}
		else {
			s->data = p->data;	//如果两个值相等，复制其中一个结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			p = p->next;		//p继续向后扫描L1
			q = q->next;		//q继续向后扫描L2
		}
	}
	r->next = NULL;		//此时将尾指针后面置空，单链表L3建成
	return true;
}

思路（差）：同时扫描两个链表，将在表1不在表2的元素放在第三个链表中。

bool Difference(LinkNode* L1, LinkNode* L2, LinkNode*& L3)	//L1、L2、L3为三个单链表的头结点
//将L1所指链表与L2所指链表求差，将在L1中不在L2中的数据复制到L3中
{
	//如果L1和L2中均没有数据
	if (L1->next == NULL && L2->next == NULL) {
		return false;
	}
	//直到L3申请成功
	while (!L3) {
		L3 = (LinkNode*)malloc(sizeof(LNode));
	}
	LinkNode* p, * q, * r, * s = NULL;
	p = L1->next;		//p为L1的工作指针
	q = L2->next;		//q为L2的工作指针
	r = L3;				//r为L3的尾指针
	//当L1和L2均不为空时
	while (p&&q) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		if (p->data < q->data) {
			s->data = p->data;	//如果此时p指向的data的值小，复制该结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			p = p->next;		//p继续向后扫描L1
		}
		else if (q->data < p->data) {
			q = q->next;		//q继续向后扫描L2
		}
		//如果两个值相等，跳过该结点
		else {
			p = p->next;		//p继续向后扫描L1
			q = q->next;		//q继续向后扫描L2
		}
	}
	//当p不为空时，将L1剩余结点接到尾指针后面
	while (p) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		s->data = p->data;	//复制结点的值
		r->next = s;		//将s接到尾指针后面
		r = r->next;		//尾指针后移
		p = p->next;		//p继续向后扫描L1
	}
	r->next = NULL;		//此时将尾指针后面置空，单链表L3建成
	return true;
}

以上三个函数中都用到了引用参数，引用参数在C++里才有，所以源代码文件格式应为".cpp"。

与主函数相结合
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

typedef int ElemType;
typedef struct LNode
{
	ElemType data;
	struct LNode* next;
}LinkNode;

bool Union(LinkNode* L1, LinkNode* L2, LinkNode*& L3);			//L1、L2、L3为三个单链表的头结点
bool Intersection(LinkNode* L1, LinkNode* L2, LinkNode*& L3);	//L1、L2、L3为三个单链表的头结点
bool Difference(LinkNode* L1, LinkNode* L2, LinkNode*& L3);		//L1、L2、L3为三个单链表的头结点
bool InitList(LinkNode*& L);		//链表产生
bool DispList(LinkNode* L);			//链表输出

int main(int argc, const char* argv[])
{
	LinkNode* L1 = NULL, * L2 = NULL, * L3 = NULL, * L4 = NULL, * L5 = NULL;
	bool flag = false;
	InitList(L1);
	InitList(L2);
	flag = Union(L1, L2, L3);
	printf("求并集：\n");
	flag = DispList(L3);
	flag = Intersection(L1, L2, L4);
	printf("求交集：\n");
	flag = DispList(L4);
	flag = Difference(L1, L2, L5);
	printf("求差集：\n");
	flag = DispList(L5);
	return 0;
}

bool InitList(LinkNode*& L)		//建立单链表
{
	while (!L) {
		L = (LinkNode*)malloc(sizeof(LNode));
	}
	L->next = NULL;
	int i, n;
	LinkNode* p = NULL, * q = NULL;
	q = L;
	printf("请输入数据规模：\n");
	scanf("%d", &n);
	printf("请输入数据：\n");
	for (i = 0; i < n; i++) {
		while (!p) {
			p = (LinkNode*)malloc(sizeof(LNode));
		}
		scanf("%d", &p->data);
		q->next = p;
		q = p;
		p = q->next = NULL;
	}
	return true;
}
bool DispList(LinkNode* L)		//输出单链表
{
	LinkNode* p = L->next;
	while (p) {
		printf("\t%d", p->data);
		p = p->next;
	}
	printf("\n");
	return true;
}
bool Union(LinkNode* L1, LinkNode* L2, LinkNode*& L3)	//L1、L2、L3为三个单链表的头结点
{
	//如果L1和L2中均没有数据
	if (L1->next == NULL && L2->next == NULL) {
		return false;
	}
	//直到L3申请成功
	while (!L3) {
		L3 = (LinkNode*)malloc(sizeof(LNode));
	}
	LinkNode* p, * q, * r, * s = NULL;
	p = L1->next;		//p为L1的工作指针
	q = L2->next;		//q为L2的工作指针
	r = L3;				//r为L3的尾指针
	//当L1和L2均不为空时
	while (p && q) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		if (p->data < q->data) {
			s->data = p->data;	//如果此时p指向的data的值小，复制该结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			p = p->next;		//p继续向后扫描L1
		}
		else if (q->data < p->data) {
			s->data =q->data;	//如果此时q指向的data的值小，复制该结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			q = q->next;		//q继续向后扫描L2
		}
		else {
			s->data = p->data;	//如果两个值相等，复制其中一个结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			p = p->next;		//p继续向后扫描L1
			q = q->next;		//q继续向后扫描L2
		}
	}
	//当p不为空时，将剩余结点接到尾指针后面
	while (p) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		s->data = p->data;	//复制结点的值
		r->next = s;		//将s接到尾指针后面
		r = r->next;		//尾指针后移
		p = p->next;		//p继续向后扫描L1
	}
	//当q不为空时，将剩余结点接到尾指针后面
	while (q) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		s->data = q->data;	//复制结点的值
		r->next = s;		//将s接到尾指针后面
		r = r->next;		//尾指针后移
		q = q->next;		//q继续向后扫描L2
	}
	r->next = NULL;		//此时将尾指针后面置空，单链表L3建成
	return true;
}
bool Intersection(LinkNode* L1, LinkNode* L2, LinkNode*& L3)	//L1、L2、L3为三个单链表的头结点
{
	//如果L1和L2中均没有数据
	if (L1->next == NULL && L2->next == NULL) {
		return false;
	}
	//直到L3申请成功
	while (!L3) {
		L3 = (LinkNode*)malloc(sizeof(LNode));
	}
	LinkNode* p, * q, * r, * s = NULL;
	p = L1->next;		//p为L1的工作指针
	q = L2->next;		//q为L2的工作指针
	r = L3;				//r为L3的尾指针
	//当L1和L2均不为空时,只要有一个为空就不会再有交集了
	while (p && q) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		if (p->data < q->data) {
			p = p->next;		//如果p偏小，继续向后扫描L1
		}
		else if (q->data < p->data) {
			q = q->next;		//如果q偏小，继续向后扫描L2
		}
		else {
			s->data = p->data;	//如果两个值相等，复制其中一个结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			p = p->next;		//p继续向后扫描L1
			q = q->next;		//q继续向后扫描L2
		}
	}
	r->next = NULL;		//此时将尾指针后面置空，单链表L3建成
	return true;
}
bool Difference(LinkNode* L1, LinkNode* L2, LinkNode*& L3)	//L1、L2、L3为三个单链表的头结点
//将L1所指链表与L2所指链表求差，将在L1中不在L2中的数据复制到L3中
{
	//如果L1和L2中均没有数据
	if (L1->next == NULL && L2->next == NULL) {
		return false;
	}
	//直到L3申请成功
	while (!L3) {
		L3 = (LinkNode*)malloc(sizeof(LNode));
	}
	LinkNode* p, * q, * r, * s = NULL;
	p = L1->next;		//p为L1的工作指针
	q = L2->next;		//q为L2的工作指针
	r = L3;				//r为L3的尾指针
	//当L1和L2均不为空时
	while (p&&q) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		if (p->data < q->data) {
			s->data = p->data;	//如果此时p指向的data的值小，复制该结点的值
			r->next = s;		//将s接到尾指针后面
			r = r->next;		//尾指针后移
			p = p->next;		//p继续向后扫描L1
		}
		else if (q->data < p->data) {
			q = q->next;		//q继续向后扫描L2
		}
		//如果两个值相等，跳过该结点
		else {
			p = p->next;		//p继续向后扫描L1
			q = q->next;		//q继续向后扫描L2
		}
	}
	//当p不为空时，将L1剩余结点接到尾指针后面
	while (p) {
		s = (LinkNode*)malloc(sizeof(LNode));
		//如果申请失败继续申请，直到申请成功，因为malloc可能申请失败
		while (!s) {
			s = (LinkNode*)malloc(sizeof(LNode));
		}
		s->data = p->data;	//复制结点的值
		r->next = s;		//将s接到尾指针后面
		r = r->next;		//尾指针后移
		p = p->next;		//p继续向后扫描L1
	}
	r->next = NULL;		//此时将尾指针后面置空，单链表L3建成
	return true;
}
Zhangjf_0612
关注
利用带头结点的单链表实现两个集合的并、交、差运算.docx
04-19
本文档的主要内容是使用带头结点的单链表实现两个集合的并、交、差运算。该文档共分为八个部分，分别是题目重述、题目功能描述、概要设计图、程序源代码及注释、流程图、截图与数据分析、所采用的存储结构的优缺点及...
c语言单链表求字符集合交,数据结构--C语言链表实现集合的（并，交，差）运算！...
weixin_42430341的博客
05-17 1988
数据结构--C语言链表实现集合的(并，交，差)运算！数据结构--C语言链表实现集合的(并，交，差)运算！老规矩，上效果图：要求：从程序完善性上考虑，集合元素输入时，要有检查元素重复的功能，每个集合中不允许有重复的元素。集合可以用数组也可以用链表存储。实现交、并、差运算时，分别把代码写成函数的形式，即实现交运算的函数，实现并运算的函数，实现差运算的函数，在主函数中分别调用三个函数。使用菜单形式对应各...
求集合(用单链表表示)的并、交和差运算
xiezhi123456的博客
01-13 5733
#include &lt;stdio.h&gt; #include &lt;malloc.h&gt; typedef char ElemType; typedef struct LNode {     ElemType data; //数据域     struct LNode *next; //指向后继结点 }LinkNode; // 声明单链表结点类型 /*-----------------...
数据结构03--单向链表集合
最新发布
weixin_69902486的博客
08-08 688
数据结构03--单向链表集合:单向不循环链表、无头单向不循环链表、单向循环链表
求集合(用有序单链表表示)的并/交和差运算
xiezhi123456的博客
07-18 3694
#include <stdio.h> #include <malloc.h> typedef char ElemType; typedef struct LNode // 定义单链表结点类型 { ElemType data; // 数据域 struct LN...
初学者关于单链表实现集合
qq_50896786的博客
04-18 1135
1.了解单链表 不同于数组结构，数组的存储单元是连续的，因此在查找时可以采用下标的方式，但单链表中的数据是以结点来表示，每个结点的构成都是由元素和指针，元素就是数据的存储单元，指针就是链接每个结点的地址数据，单链表的存放可以是连续的也可以是不连续的，因此查找不方便，没有下标的概念。 2.手写单链表各部分 1.首先是定义节点类，方便后续在单链表类中调用。 public class Node<E> {//<E>为任意类型，内部不需要强制转换类型 E ...
数据结构与算法设计_单链表
zs_life的博客
04-03 524
/*****************************************JAVA****************************************************/ JAVA封装了一个单链表的操作类 测试数据 /* * 单链表类 */ public class SingleLinkList_value { publ...
数据结构第一章习题，链表
weixin_63842313的博客
10-12 201
题目：将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来的两个链表的存储空间，不另外占用其他的存储空间。表中不允许有重复的数据。
集合运算（单链表循环）.rar_单链表对称差_循环差集_集合运算
09-15
在这个主题中，我们将深入探讨如何使用单链表实现循环差集和对称差这两种集合运算。单链表是一种基本的数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。循环链表则是一种特殊形式的链表，最后...
实现集合交并差运算c++
09-10
集合的交、并和差运算的实现...用有序单链表表示集合，实现集合的交、并和差运算。对集合中的元素，用有序单链表进行存储。实现交、并、差运算时，不另外申请存储空间。充分利用单链表的有序性，算法有较好的时间性能。
数据结构之集合的并、交和差运算
05-20
数据结构严蔚敏版，是课本里出的题目的答案。内含所有代码，EXE文件等。功能可实现
链表实现集合的并交差运算
04-28
数据结构的实验，用链表实现对集合的相关运算。
求集合的交、并和差运算
10-27
采用单链表表示集合（集合中不存在重复的元素），，并求两个集合的交、并、差
单链表表示的集合交、并、差
01-27
在本课程设计中，单链表被用来实现集合的表示和基本的集合操作——交、并、差。具体来说： #### 集合表示 集合的元素被存储在单链表的节点数据域中，每个元素可以是整型或实型。集合本身则是由一系列这样的节点...
集合的运算（C++单链表实现）.zip
04-10
通过以上步骤，我们就可以实现C++单链表对集合的交、并、差运算，并实现从文件读取和保存结果的功能。这样的实现既锻炼了对链表的理解，也展示了对文件操作的掌握，是数据结构和算法应用的一个好例子。
用单链表的方式实现集合的基本运算（数据结构C语言版）
热门推荐
luo_si_yuan的博客
11-05 1万+
①用单链表来实现结合的基本运算，首先用的是单链表所以我们就先给它创建一个头结点并且为它分配空间，而结点的结构体中定义了两个属性 data域和next指针域。 ②实现集合元素的插入。我用的是单链表头插法的方法，先创建一个新的结点用于输入值然后插入到线性链表中去，然后依次挨个的在头部插入，这里需要注意的是线性链表的头结点next指针域的指向“  p-&gt;next=L-&gt;next; L-&g...
数据结构-用单链表实现集合的并运算和交运算
m0_63581095的博客
09-24 2742
有A，B两个集合，分别用两个单链表存放，假设集合中无重复的元素，要求编写两个独立的函数分别实现集合的并运算和交运算，运算结果存放在第3个链表中（运算不能改变原来的A, B链表），假设单链表中的元素值均为正整数，建立链表时，输入-1时停止创建新结点，可以采用前插或后插的形式建立链表。【输入形式】第一行输入集合A的元素，即若干个正整数（无重复数据），各个整数之间用空格分开，最后输入-1；第二行输入集合B的元素。【输出形式】第一行输出两个集合并运算的结果，第二行输出两个集合交运算的结果。
2-1求集合（用单链表表示）的并、交和差运算
wuwuhuai的博客
02-07 3552
#include&lt;stdio.h&gt; #include&lt;malloc.h&gt; typedef char ElemType typedef struct LNode { ElemType data; struct LNode *next; } LinkNode; void CreateListF(LinkNode *&amp;L,ElemType a[],int a) ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值