用单链表实现集合的操作

合集下载

单链表表示集合 并求集合交集 并集 差集 代码

单链表表示集合  并求集合交集 并集  差集    代码
Iterator itr2 = list2.iterator();
static Scanner input = new Scanner(System.in);
public void menue() {
System.out.println("欢迎进入本系统");
System.out.println("1.输入");
package list;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
import javax.swing.JOptionPane;
public class List {
for (int i = 0; i < 4; i++) {
int number = input.nextInt();
list2.add(number);
}
System.out.println("链表1中的数据");
for (Integer s : list1) {
System.out.print(s+" ");
menue();
}
}
public void add() {
System.out.println("请往第一个链表中添加数据");
for (int i = 0; i < 4; i++) {
int number = input.nextInt();
list1.add(number);

基于单链表实现集合的交集、并集、差集的运算

基于单链表实现集合的交集、并集、差集的运算

基于单链表实现集合的交集、并集、差集的运算解题思路(单链表求交集、并集、差集的思想和顺序表求交集、并集、差集的思想基本相同)1.先通过CreateListR 函数将集合 a 和 b 中的元素添加到顺序表 ha 和 hb 中,添加过程使⽤的是顺序表原有的Initlist 函数(初始化表)和ListInsert 函数(向表中插⼊元素)。

2.因为原集合是⽆序的,所以我通过 sort 函数(选择排序),使得集合变得有序。

3.得到有序集合 ha 和 hb 后,便可以使⽤ Union 函数(类似归并的思想写出来的求并集的函数),求出 ha 和 hb 的并集。

4.⽽求交集的⽅法则是,通过将集合 a 中的元素⼀个⼀个取出,并通过函数LocateElem ,查看集合 hb 中是否存在该元素,如果存在则将元素放⼊ hc ,如果不存在,则舍去。

以此求得两集合的交集。

5.求两集合的差则可以反过来,同样通过将集合 a 中的元素⼀个⼀个取出,并通过函数LocateElem ,查看集合 hb 中是否存在该元素,如果不存在则将元素放⼊ hc ,如果存在,则舍去。

以此求得两集合的差集。

#include <iostream>#include <cstdio>#include <malloc.h>using namespace std;/* 定义单链表数据 */typedef char ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LinkList;/* 单链表的初始化 */void InitList(LinkList *&L){L = (LinkList *)malloc(sizeof(LinkList));L->next=NULL;}/* 向单链表中插⼊数据元素 */bool ListInsert(LinkList *&L,int x,char e){int j = 0;LinkList *p = L, *s;while(p!=NULL && j<x-1){p = p->next;j++;}if(p==NULL){return false;}else{s = (LinkList *)malloc(sizeof(LinkList));s->data = e;s->next = p->next;p->next = s;return true;}}/* 输出单链表 */void DispList(LinkList *L){LinkList *p = L->next;while(p!=NULL){printf("%c ",p->data);p = p->next;}printf("\n");}/* 求单链表的长度 */int ListLength(LinkList *L){LinkList *p = L->next;int i = 0;while(p!=NULL){p = p->next;}return i;}/* 查看单链表是否为空 */bool ListEmpty(LinkList *L){return L->next==NULL;}/* 求单链表中某个数据元素值 */bool GetElem(LinkList *L,int i, ElemType &e) {LinkList *p = L;int j = 0;while(p!=NULL && j < i){p=p->next;j++;}if(p==NULL){return false;}else{e = p->data;return true;}}/* 在单链表中查找元素 */int LocateElem(LinkList *L,ElemType e){LinkList *p = L;int i = 0;while(p!=NULL && p->data!=e){p = p->next;i++;}if(p==NULL){return0;}else{return i;}}/* 删除单链表中第 i 个元素*/bool ListDelete(LinkList *&L,int i,ElemType &e) {int j = 0;LinkList *p = L, *q;while(p!=NULL && j < i - 1){p = p->next;j++;}if(p==NULL)return false;else{q = p->next;if(q==NULL)return false;e = q->data;p->next = q->next;free(q);return true;}}/* 删除单链表 */void DestroyList(LinkList *&L){LinkList *p = L;LinkList *q = p->next;while(q!=NULL){p = q;q = p->next;}free(p);}void CreateListR(LinkList *&L,ElemType e[],int n) {InitList(L);int i;for(i = 0;i < n; ++i){if(!LocateElem(L,e[i]))ListInsert(L,i+1,e[i]);}}void InsterSect(LinkList *a,LinkList *b,LinkList *&c) {DestroyList(c);InitList(c);LinkList *p = a->next;int i = 0;while(p!=NULL){if(LocateElem(b,p->data))ListInsert(c,++i,p->data);p = p->next;}}void Subs(LinkList *a,LinkList *b,LinkList *&c){DestroyList(c);InitList(c);LinkList *p = a->next;int i = 0;while(p!=NULL){if(!LocateElem(b,p->data))ListInsert(c,++i,p->data);p = p->next;}}void Union(LinkList *a,LinkList *b,LinkList *&c){InitList(c);LinkList *p = a->next;LinkList *q = b->next;int k = 0;while(p!=NULL && q!=NULL){if(p->data < q->data){ListInsert(c,k+1,p->data);p = p->next;k++;}else if(p->data == q->data){ListInsert(c,k+1,p->data);p = p->next;q = q->next;k++;}else{ListInsert(c,k+1,q->data);q = q->next;k++;}}while(p!=NULL){ListInsert(c,k+1,p->data);p = p->next;k++;}while(q!=NULL){ListInsert(c,k+1,q->data);q = q->next;}///cout<<"hehe"<<endl;}void sort(LinkList *&L){LinkList *p , *pre, *q, *k;InitList(p);int i = 0;char c;while(!ListEmpty(L)){pre = L ->next;c = pre->data;while(pre!=NULL){if(c>=pre->data)c = pre->data;pre = pre->next;}ListInsert(p,++i,c);int tag = LocateElem(L,c);ListDelete(L,tag,c);}L = p;}int main( ){LinkList *ha, *hb, *hc;ElemType a[]={'c','a','e','h'};ElemType b[]={'f','h','b','g','d','a'};printf("集合的运算如下\n");CreateListR(ha,a,4);CreateListR(hb,b,6);printf("原集合 A: "); DispList(ha); printf("原集合 B: "); DispList(hb); sort(ha);sort(hb);printf("有序集合A:"); DispList(ha); printf("有序集合B:"); DispList(hb); Union(ha,hb,hc);printf("集合的并C:"); DispList(hc); InsterSect(ha,hb,hc);printf("集合的交C:"); DispList(hc); Subs(ha,hb,hc);printf("集合的差C:"); DispList(hc); DestroyList(ha);DestroyList(hb);DestroyList(hc);return0;}。

单链表实现交集和并集

单链表实现交集和并集
#include<iostream.h>
class Node {
friend class LinkList;
int data;
Node *link;
public:
Node(){link=NULL;}
};
class LinkList { //链表
Node *head; //头指针
public:
LinkList( ) { head=new Node(); }
}
}
void LinkList::print()
{
Node *p;
p=head->link;
if(head->link==NULL)
cout<<"集合为空!"<<endl;
while(p!=NULL)
{
cout<<p->data<<" ";
p=p->link;
}
cout<<endl;
}
void LinkList::Union(LinkList list1,LinkList list2)
void Create( );
void print();
voidUnion(LinkList list1,LinkList list2);
void Intersection(LinkList list1,LinkList list2);
};
void LinkList::Create()
{
int flag=0;
list2.Create();
cout<<"The first list:"<<endl;

实验4集合的交并和差运算的实现

实验4集合的交并和差运算的实现

班级:计算机11-3班学号:姓名:曲玉昆成绩:_________实验四集合的交、并和差运算的实现1. 问题描述用有序单链表表示集合,实现集合的交、并和差运算。

2. 基本要求⑴对集合中的元素,用有序单链表进行存储;⑵实现交、并、差运算时,不另外申请存储空间;⑶充分利用单链表的有序性,算法有较好的时间性能。

3. 设计思想AB。

单链表的结点结构和建立算法和首先,建立两个带头结点的有序单链表表示集合请参见教材,需要注意的是:利用头插法建立有序单链表,实参数组应该是降序排列。

其次,根据集合的运算规则,利用单链表的有序性,设计交、并和差运算。

AB的元素。

又属于集合⑴根据集合的运算规则,集合中包含所有既属于集合BA?因此,需查找单链表A和B中的相同元素并保留在单链表A中。

算法如下:的元素。

BA或属于集合中包含所有或属于集合⑵根据集合的运算规则,集合B?A xx不相同的元素,则中进行查找,若存在和B中的每个元素,在单链表A因此,对单链表A中。

算法请参照求集合的交集自行设计。

将该结点插入到单链表的元素。

因而不属于集合AB根据集合的运算规则,集合⑶ A-B中包含所有属于集合xx相同的结点,则将该中进行查找,若存在和AB此,对单链表中的每个元素,在单链表中删除。

算法请参照求集合的交集自行设计。

A结点从单链表.template<class T>struct Node{T data;Node<T>*next;};template <class T>class LinkList{public:LinkList(T a[],int n);//建立有n个元素的单链表~LinkList();void Interest(Node<T> *A, Node<T> *B);//求交集void Sum(Node<T> *A,Node<T> *B);/void Subtraction(Node<T> *A,Node<T> *B);void PrintList();void Show(int i);Node<T> *first;};template<class T>LinkList<T>::LinkList(T a[],int n){Node<T>*s;first = new Node<T>;first->next=NULL;for(int i=0;i<n;i++){s = new Node<T>;s->data=a[i];s->next=first->next;first->next=s; }}template <class T>LinkList<T>::~LinkList(){Node<T> *p,*q;p = first;//工作指针p初始化while(p) //释放单链表的每一个结点的存储空间{q = p;//暂存被释放结点p = p->next;//工作指针p指向被释放结点的下一个结点,使单链表不断开 delete q; }}template<class T>void LinkList<T>::Interest(Node<T> *A,Node<T> *B){Node<T> *pre,*p,*q;re = A;p =A ->next;q = B->next;pwhile(p&&q){if(p->data < q->data){pre->next = p->next;p = pre->next;}else if(p->data > q->data){q = q->next;}else{pre = p;p = p->next;q = q->next;} }}//求并集template<class T>void LinkList<T>::Sum(Node<T> *A,Node<T> *B{Node<T> *pre,*p,*q;pre = A; p = A->next;q = B->next;while(p&&q){if(p->data < q->data){pre = p;p = p->next;}else if(p->data > q->data){q = q->next;}else{pre->next = p->next;p = p->next;q = q->next;}}}template<class T>void LinkList<T>::Subtraction(Node<T> *A,Node<T> *B){ Node<T> *pre,*p,*q,*pra;pre = A; pra = B; p = A->next; q = B->next;while(p&&q){if(p->data < q->data){pre = p;p = p->next; }else if(p->data > q->data){q = q->next;}else{pre->next = p->next;p = pre->next;q = q->next;}}}template<class T>void LinkList<T>::PrintList(){Node<T> *p;p=first->next;//工作指针p初始化while(p != NULL)//遍历输出所有元素{cout<<p->data;p = p->next; }cout<<endl;}//菜单函数int meun(){int m;do {c畯?尼请输入对应数字(1、求交集2、求并集3、求差集4、结束运行)<<endl; cin>>m;}while(m<1||m>4);return m;}int a[]={5,4,3,2,1},b[]={6,4,2};int n = 5,m = 3;LinkList<int> SL(a,n);LinkList<int> sl(b,m);LinkList<int> s(a,n);LinkList<int> S(b,m);LinkList<int> l(a,n);LinkList<int> L(b,m);static bool bl = true;template<class T>void LinkList<T>::Show(int i){switch(i) {case 1:{Node<T> *p,*q;p = ;q = ;();();(p,q);();cout<<endl;<<endl;}break;已求交集潣瑵?case 2:{Node<T> *p,*q;p = ;q = ;();();(p,q);();();潣瑵?已求并集<<endl;}break;case 3:{Node<T> *p,*q;p = ;q = ;();();(p,q);();潣瑵?已求差集<<endl;}break;case 4:{bl = false; } break; }}void main(){while(bl == true){int i=meun();(i);}}。

实验报告1

实验报告1

实验一创建链表和链表操作一、实验目的掌握线性表的基本操作:插入、删除、查找、以及线性表合并等操作在顺序存储结构和链式存储结构上的实现。

二、实验内容:1. 创建单链表2.在链表上进行插入、删除操作;3.设计一个程序,用两个单链表分别表示两个集合,并求出这两个集合的并集。

四、测试数据:∙(3,9,5,6,11,8);在5之前插入4,7,并删除11∙求集合{1,12,8,6,4,9}和{2,5,12,7,4}的并集五、概要设计:本操作应完成如下功能:(1)创建链表说明:分配一定的空间,根据给定的链表长度输入值,创建链表。

(2)合并链表说明:将两个链表合并为一个链表只需修改链表头、尾指针即可实现。

(3)在链表中插入值说明:将给定的值插入到指定位置上,只需修改插入位置的前后结点的指针即可。

(4)在链表中删除值说明:将指定位置的值删除,只需修改删除位置的前后结点的指针即可。

六、详细设计:源代码:#include<stdio.h>#include<conio.h>#include<stdlib.h>#include<iostream.h>#define OK 1#define ERROR 0#define OVERFLOW 0//线性链表的存储结构,一个结点typedef struct LNode{int data; // 数据域struct LNode *next; // 指针域}LNode,*LinkList; //结点结构类型和指向结点的指针类型int TraverseList_L(LinkList L) //遍历单链表{LinkList p;p=L->next;while(p){printf("-->%d",p->data);p=p->next;}return OK;}//尾插法创建的带头结点的单链表。

void CreateList_L(LinkList &L,int &n){L=(LinkList)malloc(sizeof (LNode));//建立一个空链表L。

单链表求集合的并、交和差运算

单链表求集合的并、交和差运算

单链表求集合的并、交和差运算单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

在计算机科学中,我们经常需要对集合进行操作,包括求并集、交集和差集。

在本文中,我们将介绍如何使用单链表来实现这些集合操作。

我们需要定义一个单链表的数据结构。

每个节点包含一个数据元素和一个指向下一个节点的指针。

我们可以使用类来实现这个数据结构,例如:```class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = None```接下来,我们需要实现集合的并、交和差运算。

首先是并运算,它将两个集合中的所有元素合并为一个新的集合。

我们可以使用两个指针分别遍历两个链表,将两个链表中的元素逐个比较,并将不重复的元素添加到结果链表中。

具体代码如下:```def union(l1, l2):result = LinkedList()p1 = l1.headp2 = l2.headwhile p1 is not None:result.append(p1.data)p1 = p1.nextwhile p2 is not None:if not result.contains(p2.data):result.append(p2.data)p2 = p2.nextreturn result```接下来是交运算,它将两个集合中共有的元素提取出来组成一个新的集合。

同样地,我们可以使用两个指针分别遍历两个链表,将相同的元素添加到结果链表中。

具体代码如下:```def intersection(l1, l2):result = LinkedList()p1 = l1.headwhile p1 is not None:if l2.contains(p1.data):result.append(p1.data)p1 = p1.nextreturn result```最后是差运算,它将第一个集合中不属于第二个集合的元素提取出来组成一个新的集合。

单链表数据结构

单链表数据结构

插入
if (p != NULL && j == i-1) { // 找到第i个结点
s = (LinkList) malloc ( sizeof (LNode)); // 生成新结点
s->data = e;
// 数据域赋值
s->next = p->next; //新结点指针指向后一结点
p->next = s; return OK;
6、销毁
4.6 销毁操作
while(L) { p = L->next; free(L); L=p;
// p指向第一结点(头节点为“哑结点”) // 释放首结点 // L指向p
}
// 销毁完成后,L为空(NULL)
算法的时间复杂度为:O(ListLength(L))
判空 求表长
4.7 其它操作
if(L->next==NULL) return TRUE; // 空
5、清空
4.5 清空操作
while (L->next) { p = L->next; L->next = p->next; free(p);
// p指向当前结点 // 头结点指向当前结点的后结点 // 释放当前结点内存
}
// 清空完成后,仍保留头结点L
算法的时间复杂度为:O(ListLength(L))
点。
5.1.2 逆序建立单链表
①建立一个带头结点的空单链表;
②输入数据元素ai,建立新结点p, 并把p插入在头结点之后成为第一个 结点。
③重复执行②步,直到完成单链表的 建立。
a1
a2 a1
创建出来的链表 点顺序与插入操作
顺序相反。

数据结构课后答案,严蔚敏版

数据结构课后答案,严蔚敏版

void change ( SqList &L ) //写法1 { for(i=1, j=L.length; i<j; i++, j--) L.elem[i] ↔ L.elem[j]; }
习题2.22 单链表逆序 typedef struct LNode { int data; struct LNode *next; } *LinkList; void Inverse(LinkList &L) { LinkList p, q; p=L->next; while( p->next!=NULL) { q=p->next; p->next=q->next; q->next=L->next; L->next=q; } }
习题2.25 方法3
int Intersection(SqList La, SqList Lb, SqList &Lc) { int i, j, k;
if(La.length==0||Lb.length==0) return(0); //Lc.listsize=La.length<Lb.length?La.length:Lb.length; //Lc.elem=(int *)malloc(Lc.listsize*sizeof(int));
void main( ) { LinkList L1, L2, L3; int num; printf("\n初始化集合1,请输入集合1的元素个数:\n"); scanf("%d", &num); CreateList (L1, num); printf("输出集合1: "); OutputList(L1); printf("\n初始化集合2,请输入集合2的元素个数: \n"); scanf("%d", &num); CreateList(L2, num); printf("输出集合2: "); OutputList(L2); Intersection(L1, L2, L3); printf("\n输出集合1和集合2的交运算结果: "); OutputList(L3); }
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1、若 p->data>q->data,说明还未找到,需在表 B 中继续查找; 2、若 p->data<q->data,说明表 B 中无此值,处理表 A 中下一结点; 3、若 p->data=q->data,,说明找到了公共元素。 (3)求集合 A 和 B 的并集,集合 A∪B 中包含所有或属于集合 A 或属于集合 B 的元素。因此,对单链表 B 中的每一个元素 x,在单链表 A 中进行查找,若存在 和 x 不同的元素,则将该结点出入到单链表 A 中。 (4)求集合 A 和 B 的差集。根基集合的运算规则,集合 A-B 中包含所有属于集 合 A 而不属于集合 B 的元素。因此,对单链表 B 中的每个元素 x 在单链表 A 中进 行查找,若存在和 x 相同的结点,则将该结点从链表 A 中删除。 在主函数中,首先建立两个有序单链表表示集合 A 和 B,然后依次调用相应函数 实现集合的判等、交、并和差等运算,并输出运算结果。
//判断是否相等 //求交集
//求并集 //求差集
void PrintList();
void Show(int i);
private:
Node<T> *first;
};
template<class T>
LinkList<T>::LinkList(T a[],int n){
Node<T> *s;
first = new Node<T>;
//工作指针 p 初始化
while(p != NULL){
cout<<p->data;
p = p->next;
}
cout<<endl;
}
int menu(){
//菜单函数
int m;
do { cout<<"请输入对应数字(1、判断是否相等 2、求交集 3、求并集 4、求差集 5、结
束运行)"<<endl;
q = q->next;}
else{
pre->next = p->next;
p = pre->next;
q = q->next;
}
}
}
template<class T>
void LinkList<T>::PrintList(){ //遍历输出所有元素
Node<T> *p;
p=first->next;
Node<T> *pre,*p,*q,*pra;
pre = A; pra = B; p = A->next; q = B->next;
while(p!=NULL && q!=NULL){
if(p->data < q->data){
pre = p;
p = p->next;
}
else if(p->data > q->data){
cin>>m;
}while(m<1||m>5);
return m;
}
int a[]={5,4,3,2,1},b[]={6,4,2};
int n = 5,m = 3;
LinkList<int> SL(a,n); LinkList<int> sl(b,m);
LinkList<int> s(a,n); LinkList<int> S(b,m);
cout<<"相等"<<endl; } cout<<"不相等"<<endl; } break; case 2:{ Node<T> *p,*q; p = SL.first; q = sl.first; SL.PrintList(); sl.PrintList(); SL.Interest(p,q); SL.PrintList(); cout<<endl; cout<<"已求交集"<<endl;} break; case 3:{ Node<T> *p,*q; p = s.first; q = S.first; s.PrintList(); S.PrintList(); s.Sum(p,q); s.PrintList(); S.PrintList(); cout<<"已求并集"<<endl;} break; case 4:{ Node<T> *p,*q; p = l.first; q = L.first; l.PrintList();L.PrintList(); l.Subtraction(p,q); l.PrintList(); cout<<"已求差集"<<endl;} break; case 5:{ bl = false; } break;
if(p->data < q->data){
pre->next = p->next;
p = pre->next;}
else if(p->data > q->data){
q = q->next;}
else{
pre = p;
p = p->next;
q = q->next;
}
}
}
template<class T>
//建立有 n 个元素的单链表
~LinkList(); int Ifdeng(Node<T> *A, Node<T> *B); void Interest(Node<T> *A, Node<T> *B); void Sum(Node<T> *A, Node<T> *B); void Subtraction(Node<T> *A, Node<T> *B);
代码:
#include<iostream> using namespace std; template<class T> struct Node{
T data; Node<T> *next; }; template <class T> class LinkList{ public:
LinkList(T a[],int n);
pre = p;
p = p->next;}
else if(p->data > q->data){
q = q->next;}
else{
pre->next = p->next;
p = p->next; q = q->next;
}
}
}
template<class T>
//求差集
void LinkList<T>::Subtraction(Node<T> *A,Node<T> *B){
Node<T> *pa,*pb; pa=A->next; pb=B->next; while(pa!=NULL && pb!=NULL){
if(pa->data==pb->data){ pa=pa->next;
pb=pb->next;
}
else
break;
}
if(pa==NULL && pb==NULL)
//求并集
void LinkList<T>::Sum(Node<T> *A,Node<T> *B){
Node<T> *pre,*p,*q;
pre = A; p = A->next;

q = B->next;
while(p!=NULL && q!=NULL){
if(p->data < q->data){
return 1;
else
return 0;
}
template<class T>
//交集
void LinkList<T>::Interest(Node<T> *A,Node<T> *B){
Node<T> *pre,*p,*q;
pre = A;p =A ->next;q = B->next;
while(p!=NULL && q!=NULL){
LinkList<int> l(a,n); LinkList<int> L(b,m);
static bool bl = true; template<class T> void LinkList<T>::Show(int i){
switch(i){ case 1:{
Node<T> *pa,*pb; pa= s.first; pb= S.first; s.PrintList(); S.PrintList(); while(0){
} } void main(){
cout<<"集合 a[]={5,4,3,2,1}"<<endl; cout<<"集合 b[]={3,1}"<<endl;
cout<<endl; while(bl == true){
相关文档
最新文档