【数据结构】 链表表示集合并实现并集、交集、差集运算功能

最新推荐文章于 2024-04-05 21:01:13 发布
原创 最新推荐文章于 2024-04-05 21:01:13 发布 · 3.6k 阅读 · 33 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#数据结构 #c++ #链表 #算法 #集合论
本文介绍了如何使用C++通过双向链表实现集合类，包括构造函数、复制构造函数、析构函数等基本操作。此外，还详细阐述了集合的查重、插入、删除、遍历等功能，并提供了求集合的并集、交集和差集的友元函数。最后，通过main函数进行了功能测试。

总源代码在最后

  • 双向链表：
template<typename T>
struct  Node
{
	T data;
	Node* next;
	Node* prior;
};
  • 链表集合类
template<typename T>
class ListSet
{
public:
  ListSet() ；
  ListSet(const ListSet<T>& Set)；
  ~ListSet()；
  int getlength()const ；
  int findRepeated(T element)；
  void push(T  element)；
  void pop()；
  void deleteelement(int index)；
  void insert(int index, T element)；
  void print()；
  T& operator[](int index)；
  Node<T>* GetelementNode(int index)const；
  void MinusAnotherSet(ListSet & set)；
  friend ListSet<T> UnionSet(ListSet<T>& Set1, ListSet<T>&   Set2)；
  friend ListSet<T> IntersectionSet(ListSet<T> & Set1, ListSet<T> &Set2)；
private:
	Node<T>* head;
	int length;
  • 构造函数
ListSet() :length(0)
{
	head = new Node<T>;
	head->next = head;
	head->prior = head;
}
  • 复制构造函数
ListSet(const ListSet<T>& Set):length(0)
	{
		head = new Node<T>;
		head->next = head;
		head->prior = head;
		Node<T>* p = Set.GetelementNode(1);
		for (int i = 1; i <= Set.getlength(); i++)
		{
			this->push(p->data);
			p = p->next;
		}
	}
  • 析构函数
~ListSet()
	{
		while (length)  pop();
		delete head;
	}
  • 获取长度
int getlength()const { return length; }
  • 查重，若重返回下标，若无返回0
int findRepeated(T element)
{
	Node<T>* p = head;
	for (int i = 1; i <= length; i++)
	{
		p = p->next;
		if (element == p->data) return i;
	}
	return 0;
}
  • push入表
void push(T  element)
	{
		if (findRepeated(element))
		{
			cout << "element repeated is not supported by set" << endl;
			return;
		}
		Node<T>* s = new Node<T>;
		s->data = element;
		head->prior->next = s;
		s->prior = head->prior;
		s->next = head;
		head->prior = s;
		length++;
	}
  • pop出表
void pop()
{
	Node<T>*s = new Node<T>;
	s = head->prior;
	s->next = head;
	head->prior = s->prior;
	delete s;
	length--;
}
  • 指定删除
void deleteelement(int index)
	{
		if (index <= 0 || index > length)
		{
			cout << "the index which is to be deleted out of range" << endl;
			return;
		}
		int i = 0;
		Node<T>*p = head;
		while (i != index)
		{
			p = p->next;
			i++;
		}
		Node<T>* s = new Node<T>;
		s = p;
		s->prior->next = s->next;
		s->next->prior = s->prior;
		delete s;
		length--;
	}
  • 指定插入
void insert(int index, T element)
	{
		if (index > length || index <= 0)
		{
			cout << "the index which is to be inserted out of range" << endl;
			return;
		}
		if (isRepeated(element))
		{
			cout << "element repeated is not supported by set" << endl;
			return;
		}
		int i = 0;
		Node<T>*p = head;
		while (i != index - 1 && p != NULL)
		{
			p = p->next;
			i++;
		}
		Node<T>* s = new Node<T>;
		s->data = element;
		s->next = p->next;
		s->prior = p;
		p->next = s;
		s->next->prior = s;
		length++;
	}
  • 遍历输出结点值
void print()
	{
		if (!length)
		{
			cout << "no element" << endl;
			return;
		}
		Node<T>*p = head;
		for (int i = 1; i <= length; i++)
		{
			p = p->next;
			cout << p->data << " ";
		}
		cout << endl;
	}
  • 运算符重载，【】返回索引
T& operator[](int index)
	{
		if (index <= 0 || index > length)
		{
			cout << "the index which is to be got out of range" << endl;
			exit(7);
		}
		int i = 0;
		Node<T>* p = head;
		while (i != index)
		{
			p = p->next;
			i++;
		}
		return p->data;
	}
  • 由下标获得结点指针（设置为只读函数是因为在复制构造函数中常对象只能调用常函数成员）
Node<T>* GetelementNode(int index)const
	{
		if (index <= 0 || index > length)
		{
			cout << "the index which is to be got out of range" << endl;
			exit(7);
		}
		int i = 0;
		Node<T>* p = head;
		while (i != index)
		{
			p = p->next;
			i++;
		}
		return p;
	}
  • 求差集
void MinusAnotherSet(ListSet & set)
	{
		for (int j = 1; j <= set.getlength(); j++)
		{
				int index = findRepeated(set[j]);  
				if (index) deleteelement(index);    
		}
	}
  • 友元函数返回并集(模板类中的友元函数直接定义较为方便)
friend ListSet<T> UnionSet(ListSet<T>& Set1, ListSet<T>& Set2)
{
	ListSet<T> Set = Set1;              
	for (int i = 1; i <= Set2.length; i++)   
	{
		int  a = Set2[i];                      
		if (!Set1.findRepeated(a)) Set.push(a);  
	}                                          
	return Set;                                
}
  • 友元函数返回交集
	friend ListSet<T> IntersectionSet(ListSet<T> & Set1, ListSet<T> &Set2)
	{
		ListSet<T> Set;     
		for (int i = 1; i <= Set2.length; i++)
		{
			int  a = Set2[i];          
			if (Set1.findRepeated(a)) Set.push(a);   
		}                               
		return Set;
	}
private:
	Node<T>* head;
	int length;
};
  • main函数测试

int main()
{
	ListSet<int>A, B;
	A.push(1);
	A.push(2);
	A.push(6);
	A.push(2);
	A.push(8);
	A.push(9);
	B.push(1);
	B.push(6);
	B.push(7);
	cout << "A:";
	A.print();
	cout << "B:";
	B.print();
	ListSet<int>C1 = UnionSet(A, B);
	cout << "A∪B:";
	C1.print();
	ListSet<int>C2 = IntersectionSet(A,B);
	cout << "A∩B:";
	C2.print();
	cout << "execued A=A-B....." << endl;
	A.MinusAnotherSet(B);
	cout << "A:";
	A.print();
	return 0;
}
  • 总源代码:
#include<iostream>
#include<cstdlib>
using namespace std;

template<typename T>
struct  Node
{
	T data;
	Node* next;
	Node* prior;
};
template<typename T>
class ListSet
{
public:
	ListSet() :length(0)
	{
		head = new Node<T>;
		head->next = head;
		head->prior = head;
	}
	ListSet(const ListSet<T>& Set):length(0)
	{
		head = new Node<T>;
		head->next = head;
		head->prior = head;
		Node<T>* p = Set.GetelementNode(1);
		for (int i = 1; i <= Set.getlength(); i++)
		{
			this->push(p->data);
			p = p->next;
		}
	}
	~ListSet()
	{
		while (length)  pop();
		delete head;
	}
	int getlength()const { return length; }
	int findRepeated(T element)
	{
		Node<T>* p = head;
		for (int i = 1; i <= length; i++)
		{
			p = p->next;
			if (element == p->data) return i;
		}
		return 0;
	}          
	void push(T  element)
	{
		if (findRepeated(element))
		{
			cout << "element repeated is not supported by set" << endl;
			return;
		}
		Node<T>* s = new Node<T>;
		s->data = element;
		head->prior->next = s;
		s->prior = head->prior;
		s->next = head;
		head->prior = s;
		length++;
	}
	void pop()
	{
		Node<T>*s = new Node<T>;
		s = head->prior;
		s->next = head;
		head->prior = s->prior;
		delete s;
		length--;
	}
	void deleteelement(int index)
	{
		if (index <= 0 || index > length)
		{
			cout << "the index which is to be deleted out of range" << endl;
			return;
		}
		int i = 0;
		Node<T>*p = head;
		while (i != index)
		{
			p = p->next;
			i++;
		}
		Node<T>* s = new Node<T>;
		s = p;
		s->prior->next = s->next;
		s->next->prior = s->prior;
		delete s;
		length--;
	}
	void insert(int index, T element)
	{
		if (index > length || index <= 0)
		{
			cout << "the index which is to be inserted out of range" << endl;
			return;
		}
		if (isRepeated(element))
		{
			cout << "element repeated is not supported by set" << endl;
			return;
		}
		int i = 0;
		Node<T>*p = head;
		while (i != index - 1 && p != NULL)
		{
			p = p->next;
			i++;
		}
		Node<T>* s = new Node<T>;
		s->data = element;
		s->next = p->next;
		s->prior = p;
		p->next = s;
		s->next->prior = s;
		length++;
	}
	void print()
	{
		if (!length)
		{
			cout << "no element" << endl;
			return;
		}
		Node<T>*p = head;
		for (int i = 1; i <= length; i++)
		{
			p = p->next;
			cout << p->data << " ";
		}
		cout << endl;
	}
	T& operator[](int index)
	{
		if (index <= 0 || index > length)
		{
			cout << "the index which is to be got out of range" << endl;
			exit(7);
		}
		int i = 0;
		Node<T>* p = head;
		while (i != index)
		{
			p = p->next;
			i++;
		}
		return p->data;
	}
	Node<T>* GetelementNode(int index)const
	{
		if (index <= 0 || index > length)
		{
			cout << "the index which is to be got out of range" << endl;
			exit(7);
		}
		int i = 0;
		Node<T>* p = head;
		while (i != index)
		{
			p = p->next;
			i++;
		}
		return p;
	}
	void MinusAnotherSet(ListSet & set)
	{
		for (int j = 1; j <= set.getlength(); j++)
		{
				int index = findRepeated(set[j]);   
				if (index) deleteelement(index);   
		}
	}
	friend ListSet<T> UnionSet(ListSet<T>& Set1, ListSet<T>& Set2)
	{
		ListSet<T> Set = Set1;                 
		for (int i = 1; i <= Set2.length; i++)   
		{
			int  a = Set2[i];                      
			if (!Set1.findRepeated(a)) Set.push(a);  
		}                                         
		return Set;                                
	}
	friend ListSet<T> IntersectionSet(ListSet<T> & Set1, ListSet<T> &Set2)
	{
		ListSet<T> Set;     
		for (int i = 1; i <= Set2.length; i++)
		{
			int  a = Set2[i];         
			if (Set1.findRepeated(a)) Set.push(a);   
		}                             
		return Set;
	}
private:
	Node<T>* head;
	int length;
};

int main()
{
	ListSet<int>A, B;
	A.push(1);
	A.push(2);
	A.push(6);
	A.push(2);
	A.push(8);
	A.push(9);
	B.push(1);
	B.push(6);
	B.push(7);
	cout << "A:";
	A.print();
	cout << "B:";
	B.print();
	ListSet<int>C1 = UnionSet(A, B);
	cout << "A∪B:";
	C1.print();
	ListSet<int>C2 = IntersectionSet(A,B);
	cout << "A∩B:";
	C2.print();
	cout << "execued A=A-B....." << endl;
	A.MinusAnotherSet(B);
	cout << "A:";
	A.print();
	return 0;
}
数据结构 课程设计 用链表实现集合并集 c++
01-16
数据结构 课程设计 用链表实现集合并集 c++
链表求交集、并集和差集
17的博客
09-28 3904
用C语言建立链表，输入集合A和集合B，求集合A和B的交集、并集和差集
C语言利用链表求集合的交集
Xenoverse的博客
12-12 3761
Description  假设元素依值递增有序排列的线性表A和B分别表示两个集合（即同一表中的元素值各不相同），现要求另辟空间构成一个线性表C，其元素为A和B中元素的交集，且表C中的元素也依值递增有序排列。 输入A和B集合中的元素； 输出A和B的交集C中的元素。 提示：存储结构采用带表头结点的循环单链表，结点结构如下： typedef struct Node {     int da...
离散数学：求集合的并、交、差、环和（c语言链表实现）
m0_53621849的博客
11-25 5544
给定两个集合A，B，求其并、交、差、环和 输入分为两行，第一行输入集合A,第二行输入集合B, 其中各包括若干个元素,每个元素用“，”隔开，用“{}”表示空集。元素按照字典序排列。 输出格式： 输出分为4行，第一行输出A∪B的集合，第二行输出A∩B的集合，第三行输出A-B的集合，第四行输出A⊕B的集合。元素按照字典序排列。 输入样例： {a,b,c,d} {c,d,...
链表简单实现集合交并
沉在海里的鱼的博客
10-11 3319
直接上代码： ​ #include<iostream> using namespace std; typedef struct Set { int data; struct Set* next; }*set; set CreateSet(int n) {//创建集合 set head = (set)malloc(sizeof(struct Set)); head->next = NULL; set p = head; for (int i = 0; i < n; i
数据结构学习笔记——用链表实现交、并、补集
m0_58327740的博客
11-14 1906
求集合（用单链表表示）的并、交和差运算 1.问题描述 集合运算如下： 原集合A：c a e h 原集合B：f h b g d a 有序集合A：a c e h 有序集合B：a b d f g h 集合的并C：a b c d e f g h 集合的交C：a h 集合的差C：c e 2.算法设计与代码实现 #include<bits/stdc++.h> using namespace std; typedef char ElemType; typedef struct Lode
单链表实现集合的交并差Java_数据结构课程设计报告---单链表表示集合---实现交并差...
weixin_39577052的博客
02-25 912
数据结构课程设计报告---单链表表示集合---实现交并差 西安建筑科技大学华清学院课程设计(论文)题 目： 院 (系)： 专业班级： 计算机 姓 名： 学 号： 指导教师： 2016 年 9 月 8 日西安建筑科技大学华清学院课程设计(论文)任务书专业班级： 学生姓名： 指导教师(签名)： 一、课程设计(论文)题目集合运算： 使用链表来表示集合，完成集合的合并，求交集等操作。二、本次课程设计(论文...
采用递增有序的顺序表表示集合，求解两个集合的交、并集
热门推荐
黑面宝宝的博客
10-08 1万+
采用递增有序的顺序表表示集合，求解两个集合的交、并集 （1）定义顺序表的存储结构； （2）实现存储递增有序集合的顺序表的建立、求交集运算； //  main.cpp //  数据结构作业 // //  Created by 周 on 16/10/7. //  Copyright © 2016年 周. All rights reserved. //
集合的运算（C++单链表实现）
weixin_44932349的博客
04-10 2768
集合的运算1.需求分析2.数据结构与模块化设计2.1 数据结构设计2.2 模块化设计2.3 总体功能流程图3.程序设计4.运行展示 1.需求分析 （1）建立两个含有若干个元素的单链表 A、B , 要求从文件读入数据，显示、保存函数公用。 集合的元素不限定，可以是大小写字母。演示程序以用户和计算机的对话方式执行。 （2）集合中（A与B的交集）包含所有既属于集合 A 又属于集合 B 的元素，显示计算后的结果并保存。 （3）集合中（A与B的并集）包含所有或属于集合 A 或属于集合 B 的元素， 显示计算后的结果并
数据结构中集合的交集并集差集的实验报告
jgrttg的博客
04-05 1266
数据结构中集合的交集并集差集的实验报告 C语言代码
用有序单链表表示集合，实现集合的交、并、差运算 基本要求： 空间复杂度为 O(1)
weixin_45863084的博客
07-26 5577
二、课程设计内容及要求 集合的交、并和差运算的实现 问题描述：用有序单链表表示集合，实现集合的交、并、差运算 基本要求： 空间复杂度为 O(1) 系统功能模块 4.1输出和销毁函数设计 void DispList(LinkList*L) { LinkList *p=L->next; while(p!=NULL) { cout<<"%c “,p->data; p=p->next; } cout<<”\n"; } void DestroyList(LinkL
【数据结构】实验三 求两个集合（用单链表表示）的并、交和差运算
weixin_61693556的博客
04-08 6480
实验要求：在实验二的基础上，使用单链表表示集合，编写三个算法（求交算法、求并算法、集合求差），并输出最终的结果。 例如： 集合A为（3、4、1、6），集合B为（2、3、6、7） 交集为：（3、6） 并集为：（1、2、3、4、6、7） 差集为：（1、4） （注意：差集C=A-B,即属于A但不属于B的元素的集合） #include<iostream> using namespace std; #define ElemType char typedef struct LNode // 定义结构体.
【纯C语言】数据结构：线性表对集合创建、交集、并集、输出
fangzelin5的博客
04-01 1641
【纯C语言】线性表对集合创建、交集、并集、输出
求集合(用有序单链表表示)的并/交和差运算
xiezhi123456的博客
07-18 3829
#include <stdio.h> #include <malloc.h> typedef char ElemType; typedef struct LNode // 定义单链表结点类型 { ElemType data; // 数据域 struct LN...
数据结构课程设计——集合的交、并和差运算
随风飘荡的鱼儿的博客
05-22 7494
程序运行后会显示菜单，用户可以根据菜单号输入相对应的数字，（如果用户输入1，程序将对两个集合进行并集运算并输出相应结果，用户输入2，程序将对两个集合进行交集运算对输出需要结果，用户输入3，程序将对两个集合进行差集运算并输出相应的结果，用户输入0，则程序运行结束，退出系统。操作结果：若有序表L存在元素e，则q指示L中第一个值为e的元素的位置，并返回函数值TRUE，否则q指示第一个大于e的元素的前驱的位置，并返回函数值FALSE。集合B已经遍历结束，集合A没有，将集合A中剩下所有元素插入，并且是不重复插入。
线性表之单链表求集合并集
qq_45280880的博客
10-21 3085
线性表之单链表求集合并集 学习目标： 掌握以下内容 1、单链表的创建 2、将数据插入单链表 3、单链表合并 4、单链表去重 学习时间： 2020/10/20 学习产出： CSDN 技术博客 1 篇 哔哩哔哩专栏1篇 文章目录线性表之单链表求集合并集学习目标：学习时间：学习产出：一、自定义结构体二、初始化单链表三、单链表长度测量四、 在第i个位置插入结点五、单链表排序（递增）六、单链表去除重复元素五、两个链表并集六、主函数七、调用函数库 一、自定义结构体 typedef char elem; typedef
C语言数据结构之求两个集合的交集（链表）
weixin_30951231的博客
09-23 3296
//1：求两集合的交集(链表)。 #include <stdio.h> #include <stdlib.h> struct node { int data; struct node* next; }; void push(struct node **head_ref, int new_data); //添加数...
Python自学14——第七章（2）：什么是集合、集合的创建、集合的增删改操作、集合间的关系、集合的数学操作
weixin_48304306的博客
06-01 1067
Python自学14——第七章（2）：什么是集合、集合的创建、集合的增删改操作、集合间的关系、集合的数学操作
链表中的并集和交集（c/c++实现）
gets_s的博客
04-12 4975
使用单链表表示集合。编写两个算法（求交算法和求并算法），并输出最终的结果。 测试用例：集合A为{3，4，1，6}，集合A为{2，3，6，7}， 交集为{3，6} 并集为{1，2，3，4，6，7} #include<windows.h> #include<stdio.h> #include<iostream> using namespace std; #defin...
C 语言用链表实现集合交并差,集合交差并三种操作的C实现
weixin_31184569的博客
05-22 2096
这段时间一直在看C++相关的数据结构，感觉STL库的出现确实给C++实现一些基本的数据结构更加的方便，特别是map、list、set、vector的灵活运用能实现很多强大的数据结构，记得在一本书中曾经读到过“C++中算法的重要性没有C语言中那么明显，而是设计方法的问题”这句话的正确性有待于进一步的考察，但是面向对象中的更多的是依靠继承多态性实现多对象编程，而在C语言中更多的事依靠算法和数据结构。花...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值