线性表的应用实例（交并差）

最新推荐文章于 2023-02-03 11:04:45 发布
最新推荐文章于 2023-02-03 11:04:45 发布
阅读量573 收藏 6
点赞数 1
分类专栏： C语言 文章标签： 链表 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/frozen122/article/details/115448911
版权

整数集合用单链表实现存储，实现如下操作：

（1） 初始化集合

（2）插入一个数到集合指定位置

（3）按值删除集合中的元素

（4）按值在集合中进行查找

（5）清空集合

（6）求两个集合的交集

（7）求两个集合的并集

（8）求两个集合的差集

（9）输出集合

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

typedef int ElemType;
typedef struct Lnode
{
	ElemType data;
	struct Lnode* next;
}Lnode, * LinkList;
int initList(LinkList* L)
{
	(*L) = (LinkList)malloc(sizeof(Lnode));
	(*L)->next = NULL;
	return 1;
}
int insertList(LinkList L, int i, ElemType e)    //最基本的按位序插入
{
	LinkList p = L, q;
	int pos = 0;
	if (p == NULL)
		return 0;
	while (p->next && pos < i - 1)
	{
		p = p->next;
		pos++;
	}
	q = (LinkList)malloc(sizeof(Lnode));
	q->data = e;
	q->next = p->next;
	p->next = q;
	return 1;
}
int printList(LinkList L)    //为了不打乱按位序插入的结果，用普通的方法输出
{
	LinkList p = L->next;
	if (p == NULL)
		return 0;
	while (p)
	{
		printf("%d      ", p->data);
		p = p->next;
	}
	printf("\n");
	return 1;
}
int rearinsertList(LinkList L, ElemType e)    //尾插，和排序输出配合使用
{
	LinkList p = L, q;
	if (p == NULL)
		return 0;
	while (p->next)
		p = p->next;
	q = (LinkList)malloc(sizeof(Lnode));
	q->data = e;
	q->next = NULL;
	p->next = q;
	return 1;
}
int sortPrintList(LinkList L)    //排序输出
{
	LinkList p = L->next, q = L->next;
	int e;
	if (p == NULL)
		return 0;
	while (q)
	{
		while (p->next)
		{
			if (q->data > p->next->data)
			{
				e = p->data;
				q->data = p->next->data;
				p->next->data = e;
			}
			p = p->next;
		}
		printf("%d       ", q->data);
		q = q->next;
		p = q;
	}
	printf("\n");
	return 1;
}
int creatList(LinkList* L)
{
	initList(L);
	LinkList p = *L, q;
	ElemType e;
	int i = 1;
	char yn;
	do
	{
		printf("请输入第%d个数据\n", i);
		i++;
		scanf("%d", &e);
		getchar();
		if (rearinsertList(p, e))
			printf("添加成功！是否继续添加数据？\n");
		yn = getchar();
	} while (yn == 'Y' || yn == 'y');
	return 1;
}
int deleteList(LinkList L, int e)    //按值删除
{
	LinkList p = L, q;
	if (p == NULL)
		return 0;
	while (p->next != NULL && p->next->data != e)
		p = p->next;
	q = p->next;
	p->next = q->next;
	free(q);
	return 1;
}
int locationList(LinkList L, int i)    //查找
{
	LinkList p = L;
	int j = 0;
	while (p)
		if (p->data != i)
		{
			p = p->next;
			j++;
		}
		else return j;
	if (p == NULL)
		return 0;
}
int cleanList(LinkList L)    //清空
{
	LinkList p = L;
	while (L->next)
	{
		p = L->next;
		L->next = p->next;
		free(p);
	}
	return 1;
}
int mixedList(LinkList La, LinkList Lb, LinkList Lc)
{
	LinkList pa = La->next, pb = Lb->next, pc = Lc, p;
	while (pa && pb)
	{
		if (pa->data == pb->data)
		{
			rearinsertList(Lc, pa->data);
			pa = pa->next;
			pb = pb->next;
		}
		else if (pa->data < pb->data)
			pa = pa->next;
		else if (pa->data > pb->data)
			pb = pb->next;
	}
	return 1;

}
int unionList(LinkList La, LinkList Lb, LinkList Lc)
{
	LinkList pa = La->next, pb = Lb->next, pc = Lc, p;
	while (pa && pb)
	{
		if (pa->data == pb->data)
		{
			rearinsertList(pc, pa->data);
			pa = pa->next;
			pb = pb->next;
		}
		else if (pa->data < pb->data) {
			rearinsertList(pc, pa->data);
			pa = pa->next;
		}
		else if (pa->data > pb->data) {
			rearinsertList(pc, pb->data);
			pb = pb->next;
		}
	}
	while (pa) {
		rearinsertList(pc, pa->data);
		pa = pa->next;
	}
	while (pb) {
		rearinsertList(pc, pb->data);
		pb = pb->next;
	}
	return 1;
}
int diffList(LinkList La, LinkList Lb, LinkList Lc)
{
	LinkList pa = La->next, pb = Lb->next, pc = Lc, p;
	while (pa && pb)
	{
		if (pa->data == pb->data)
		{
			pa = pa->next;
			pb = pb->next;
		}
		else if (pa->data < pb->data) {
			rearinsertList(pc, pa->data);
			pa = pa->next;
		}
		else if (pa->data > pb->data) {
			rearinsertList(pc, pb->data);
			pb = pb->next;
		}
	}
	while (pa) {
		rearinsertList(pc, pa->data);
		pa = pa->next;
	}
	while (pb) {
		rearinsertList(pc, pb->data);
		pb = pb->next;
	}
	return 1;
}
int main()
{
	LinkList L, La = NULL, Lb = NULL, Lc = NULL;
	printf("开始新建链表：\n");
	creatList(&L);
	printf("链表L为：");
	sortPrintList(L);
	ElemType e;
	printf("\n请选择你需要的操作：\n");
	printf("1：插入\n");
	printf("2：删除\n");
	printf("3：查找\n");
	printf("4：清空\n");
	printf("5：交(使用链表AB)\n");
	printf("6：并(使用链表AB)\n");
	printf("7：差(使用链表AB)\n");

	int op;
	while (scanf("%d", &op) && op) {
		if (op == 1) {
			printf("请输入需要插入的位置：");
			int i;
			scanf("%d", &i);
			printf("请输入需要插入的元素：");
			scanf("%d", &e);
			if (insertList(L, i, e))
				printf("插入成功！\n");
			else
				printf("插入失败！");
			printf("最新的链表为：\n");
			printList(L);
		}
		else if (op == 2)
		{
			printf("请输入需要删除的值：");
			int e;
			scanf("%d", &e);
			if (deleteList(L, e))
				printf("删除成功!\n");
			else
				printf("删除失败！\n");
			printf("最新的链表为：\n");
			sortPrintList(L);
		}
		else if (op == 3)
		{
			printf("请输入需要查找的元素：");
			int i;
			scanf("%d", &i);
			if (locationList(L, i))
				printf("该元素位于第%d个\n", locationList(L, i));
			else
				printf("未查询到该元素！\n");
		}
		else if (op == 4)
		{
			if (cleanList(L))
				printf("清空成功！\n");
		}
		else if (op == 5)
		{
			char yn;
			if (La == NULL)
			{
				if (L->next)
				{
					getchar();
					printf("链表A为空，是否使用链表L做为链表A？Y/N\n");
					yn = getchar();
					if (yn == 'Y' || yn == 'y')
					{
						initList(&La);
						La = L;
						printf("最新的链表A为：");
						sortPrintList(La);
					}
					else
					{
						printf("链表A为空，开始新建链表A：\n");
						creatList(&La);
					}
				}
				else
				{
					printf("链表A为空，开始新建链表A：\n");
					creatList(&La);
				}
			}
			else
			{
				getchar();
				printf("链表A非空，是否需要新建？\n");
				yn = getchar();
				if (yn == 'Y' || yn == 'y')
					creatList(&La);
				else
				{
					printf("继续使用，最新的链表A为：");
					sortPrintList(La);
				}
			}
			if (Lb == NULL)
			{
				printf("链表B为空，开始新建链表B：\n");
				creatList(&Lb);
			}
			else
			{
				getchar();
				printf("链表B非空，是否新建？\n");
				yn = getchar();
				if (yn == 'Y' || yn == 'y')
					creatList(&Lb);
				else
				{
					printf("继续使用链表B，最新的链表B为：");
					sortPrintList(Lb);
					printf("\n");
				}
			}
			initList(&Lc);
			mixedList(La, Lb, Lc);
			printf("链表A为：");
			sortPrintList(La);
			printf("链表B为：");
			sortPrintList(Lb);
			printf("链表AB的交集为");
			if (sortPrintList(Lc) == 0)
				printf("：空\n");
		}
		else if (op == 6)
		{
			char yn;
			if (La == NULL)
			{
				if (L->next)
				{
					getchar();
					printf("链表A为空，是否使用链表L做为链表A？Y/N\n");
					yn = getchar();
					if (yn == 'Y' || yn == 'y')
					{
						initList(&La);
						La = L;
						printf("最新的链表A为：");
						sortPrintList(La);
					}
					else
					{
						printf("链表A为空，开始新建链表A：\n");
						creatList(&La);
					}
				}
				else
				{
					printf("链表A为空，开始新建链表A：\n");
					creatList(&La);
				}
			}
			else
			{
				getchar();
				printf("链表A非空，是否需要新建？\n");
				yn = getchar();
				if (yn == 'Y' || yn == 'y')
					creatList(&La);
				else
				{
					printf("继续使用，最新的链表A为：");
					sortPrintList(La);
				}
			}
			if (Lb == NULL)
			{
				printf("链表B为空，开始新建链表B：\n");
				creatList(&Lb);
			}
			else
			{
				getchar();
				printf("链表B非空，是否新建？\n");
				yn = getchar();
				if (yn == 'Y' || yn == 'y')
					creatList(&Lb);
				else
				{
					printf("继续使用链表B，最新的链表B为：");
					sortPrintList(Lb);
					printf("\n");
				}
			}
			initList(&Lc);
			printf("链表A为：");
			sortPrintList(La);
			printf("链表B为：");
			sortPrintList(Lb);
			unionList(La, Lb, Lc);
			printf("链表AB的并集为");
			if (sortPrintList(Lc) == 0)
				printf("：空\n");
		}
		else if (op == 7)
		{
			char yn;
			if (La == NULL)
			{
				if (L->next)
				{
					getchar();
					printf("链表A为空，是否使用链表L做为链表A？Y/N\n");
					yn = getchar();
					if (yn == 'Y' || yn == 'y')
					{
						initList(&La);
						La = L;
						printf("最新的链表A为：");
						sortPrintList(La);
					}
					else
					{
						printf("链表A为空，开始新建链表A：\n");
						creatList(&La);
					}
				}
				else
				{
					printf("链表A为空，开始新建链表A：\n");
					creatList(&La);
				}
			}
			else
			{
				getchar();
				printf("链表A非空，是否需要新建？\n");
				yn = getchar();
				if (yn == 'Y' || yn == 'y')
					creatList(&La);
				else
				{
					printf("继续使用，最新的链表A为：");
					sortPrintList(La);
				}
			}
			if (Lb == NULL)
			{
				printf("链表B为空，开始新建链表B：\n");
				creatList(&Lb);
			}
			else
			{
				getchar();
				printf("链表B非空，是否新建？\n");
				yn = getchar();
				if (yn == 'Y' || yn == 'y')
					creatList(&Lb);
				else
				{
					printf("继续使用链表B，最新的链表B为：");
					sortPrintList(Lb);
					printf("\n");
				}
			}
			initList(&Lc);
			printf("链表A为：");
			sortPrintList(La);
			printf("链表B为：");
			sortPrintList(Lb);
			diffList(La, Lb, Lc);
			printf("链表AB的差集为");
			if (sortPrintList(Lc) == 0)
				printf("：空\n");
		}
		else
		printf("输入有误，请检查后再次输入！\n");
	}
}
frozen122
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表实例
Fire的博客
08-02 2599
线性表的本质：由0个或多个数据元素组成的集合 数据元素之间是顺序的 数据元素个数是有限的 数据元素的类型必须是相同的 专业的定义：线性表是具有相同类型的n(n>=0)个数据元素的有限序列（a0，a1，a2，...an） ai是表项，n是长度 性质：a0为线性表中的第一个元素，只有一个后继 an为线性表中的最后一个元素，只有一个前驱 除了a0和an之外的其他元素ai，既有一个直接前驱，也有一个直接后继
数据结构-线性表
weixin_62313265的博客
03-19 2802
在日常生活中，线性表的例子比比皆是。例如，26个英文字母的字母表就是一个线性表，表中的数据元素是单个字母。 在稍复杂的线性表中，一个数据元素可以包含若干个数据项。例如在一个学生基本信息表中，每个学生为一个数据元素，包括学号、姚名、性别、籍贯、专业等数据项。 由以上示例可以看出，它们的数据元素虽然不同，但同一线性表中的元素必定具有相同的特性，即属于同一数据对象，相邻数据元素之间存在着序偶关系。 1.线性表的定义和特点 定义： 由n(n≥0)个...
数据结构----线性表应用案例
qq_38198286的博客
06-28 3335
目录1.顺序表和链表的比较2.线性表的合并3.有序表的合并（1）顺序表实现（2）链表实现4.多项式运算5.稀疏多项式运算6.图书信息管理 1.顺序表和链表的比较 2.线性表的合并 3.有序表的合并 （1）顺序表实现 （2）链表实现 （前提是有序链表） 1，两个指针pa，pb指向待操作链表的首元结点，以la的头结点作为lc的的头结点，pc指向lc头结点。 2，当pa和pb都非空时，比较指向结点的data域，将data域较小的结点地址赋给pc指向结点的next域，再移动pc和较小结点指针，直
线性表的应用举例
HLXchamp的博客
05-04 717
一元多项式的表示及相加 1、一元多项式的表示： 一元多项式可按升幂的形式写成： Pn(x)P_n(x)Pn​(x) = p0p_0p0​ + p1p_1p1​x1x^1x1 + p2p_2p2​x2x^2x2 + … + pnp_npn​xnx^nxn， PiP_iPi​是指数i项的系数. 一元多项式Qm(x)Q_m(x)Qm​(x)可用线性表Q来表示. Q= (q0q_0q0​，q1q_1q1​...
c语言如何用线性表求交并补集,利用线性表的顺序结构求集合的并、交、差、补（C语言实现）...
weixin_29138345的博客
05-22 2466
昨天用数据结构中的线性表的顺序结构实现了关于集合的并、交、差、补的集合运算，做个记录，希望也能帮助到其他人。一、算法分析(1)用数组A，B，C，E表示集合。假定A={1,3，4，5，6，7，9，10},B={2，,3，4，7，8，10}, E={1,2，3，4，5，6，7，8，9，10},输入数组A，B，E(全集)，输入数据时要求检查数据是否重复(集合中的数据要求不重复)，要求集合A，B是集合E的...
线性表应用举例
zlz18225318697的博客
11-21 1585
编程实现学生成绩管理系统，次系统具有查询，修改，删除，增加和求全班各门课平均分的功能。要求采用顺序存储结构。 package com.test1;import java.awt.DisplayMode; import java.util.Scanner;public class StudentManageSystem extends SqList {//按顺序构造顺序表，其中参数maxS
集合并、交、差运算演示
05-22
通过这个实验，他们加深了对有序线性表的理解，熟悉了C语言和上机操作，意识到实践的重要性。 8. **程序代码**： 提供的附录中包含了程序的部分源代码，但不完整。完整的程序应该包含了上述所有链表操作的实现。 ...
数据结构算法与应用-C C++语言描述
11-19
1.4.2 使用不同的描述方法 18 1.4.3 操作符重载 20 1.4.4 引发异常 22 1.4.5 友元和保护类成员 23 1.4.6 增加#ifndef, #define和#endif语句 24 1.5 测试与调试 24 1.5.1 什么是测试 24 1.5.2 设计测试数据 26 1.5.3 ...
数据结构、算法与应用--C++语言描述
05-09
1.4.2 使用不同的描述方法 18 1.4.3 操作符重载 20 1.4.4 引发异常 22 1.4.5 友元和保护类成员 23 1.4.6 增加#ifndef, #define和#endif语句 24 1.5 测试与调试 24 1.5.1 什么是测试 24 1.5.2 设计测试数据 26 1.5.3 ...
数据结构算法与应用-C__语言描述
01-19
更为可贵的是，本书不仅仅介绍了理论知识，还提供了50多个应用实例及600多道练习题。 本书内容广博权威，结构清晰合理，是一本全新的有关数据结构与算法的教材，对于计算机科学与工程领域的从业人员也是一本很好的...
利用C语言线性表实现集合的交并差.cpp
04-12
编制一个能演示执行集合的并、交、差运算的程序。 （1）设计集合的并、交、差运算函数（集合的元素不能重复） （2）编制测试函数测试集合运算 （3）提示：以有序链表表示集合
线性表简单易懂的例子！原创！！调试通过！
10-03
新手必备的例子，我自学时写的！可以给你个参照！！
数据结构： 线性表讲解实例
11-03
数据结构： 线性表讲解实例。针对线性表的深入讲解。
数据结构算法与应用(C++语言描述).rar
02-28
1.4.2 使用不同的描述方法 18 1.4.3 操作符重载 20 1.4.4 引发异常 22 1.4.5 友元和保护类成员 23 1.4.6 增加#ifndef, #define和#endif语句 24 1.5 测试与调试 24 1.5.1 什么是测试 24 1.5.2 设计测试数据 26 1.5.3 ...
【数据结构（4）】线性表的定义、特点及案例引入
最新发布
shangguanxiu的博客
02-03 1782
严蔚敏版【数据结构】2.1 线性表的定义和特点。2.2 线性表的应用案例：1. 一元多项式的计算 、2. 稀疏多项式的计算。3. 图书信息管理系统
数据结构——“线性表的应用举例“ 深度分析学完线性表工作中应用在哪？
weixin_44278698的博客
04-28 4827
线性表的应用举例引言应用举例应用一：多项式的处理应用二：Joseph问题（约瑟夫算法）joseph代码示例： 引言 我们前面学习了线性表的顺序存储，顺序表的链式存储，但是在实际运用过程中我们该如何应用呢？ 应用举例 应用一：多项式的处理 多项式表示 与 相加: 设一元n次多项式: 它的n+1个系数可形成一个线性表:p(p0，p1，… ，pn)，而x的指数i(0 ≤i ≤ n)对应系数 pi 的序号。无疑Pn(x)中有许多系数为0的项，如: 我们看个多项式的案例： 对于这样繁琐的多项式合并计算，如果多
线性表(数据结构)
m0_52397715的博客
03-27 3576
第二章 线性表 线性表是最基本且最常用的一种线性结构，同时也是其他数据结构的基础，尤其是单链表，是贯穿整个数据结构的基本技术。 2.1 线性表的定义和特点 在日常生活中，线性表的例子比比皆是，例如26个英文字母的字母表： (A,B,C,D…,Z),其是一个线性表，表中的数据元素是单个字母，在稍微复杂度的线性表中，一个数据元素可以包含若干个数据项，例如所涉及的学生信息表，每个学生为一个数据元素，包括学号、姓名、性别、籍贯、专业等数据项。 由以上实例可以看出，它们的数据元素虽然不同，但同一线性表中的元素必定具
【数据结构（10）】2.8 线性表的案例分析与实现
shangguanxiu的博客
12-28 773
严蔚敏版【数据结构】1. 一元多项式的运算。 2. 稀疏多项式的运算： 多项式创建、 多项式的相加。 3. 图书信息管理系统。
线性表相关实例
chenxiaozhen22的博客
09-01 140
学习视频是华中大的内容，感谢分享 如果直接按照以前的思路，这个我自己纯c语言思路实现，不可能这么简洁。水平有限，基本是要另外创建一个新的数组来存放非零元素，然后最后再给其他空余位置赋零。但是一个好的算法，就是简洁。num[j++] = num[i]真的是妙。j++保证了非零数据可以按序赋值进去。第二个for循环，前面已经把非零元素都赋值好了，这边就把剩下的位置直接赋零。优美，奈斯 temp临时保持num[i]的数值 假定每个num[i]都是0 并对其赋值为0如果本次循序的temp比对不是0那就把本次对
数据结构：二叉排序树构建实例与数据结构基础
本资源是一份关于数据结构的讲义，旨在教授学生如何通过实例理解和应用数据结构的基本概念和算法。课程包括理论讲解和实践操作，共分为多个章节，如第一章绪论、线性表、栈和队列、串、数组与广义表、树与二叉树、图...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值