精华内容
下载资源
问答
  • C语言数据结构课程设计,集合交并差,分部完成实验报告。
  • 运用数据结构中的链表的相关的知识,实现集合交并差,加深对链表的插入删除清空等操作的理解。
  • 关于数据结构课程设计,资源来至于课本,进行的集合交并差运算
  • 数据结构实习的作品,可以运行的~用相应函数实现集合交并差运算,以单链表的形式实现,可行性良好
  • 数据结构课程设计 集合交并差运算 编 号730 拉桂宅孑科弑火遂 GUILIN UNIVERSITY OF ELECTRONIC TECHNOLOGY 数据结构与算法课程设计 说明书 集合交并差运算 学 院 海洋信息工程学院 专 业 四络工程 学生姓名 xx ...
  • 实验1 集合交并差 要求: (1)实验目的 通过该实验,让学生复习巩固C语言中的循环结构、循环控制条件、分支结构和数组/链表、函数的调用等有关内容,体会到用数组存储集合时,需要记录集合元素的个数,否则输出...

    实验1 集合的交并差


    要求:
    (1)实验目的
    通过该实验,让学生复习巩固C语言中的循环结构、循环控制条件、分支结构和数组/链表、函数的调用等有关内容,体会到用数组存储集合时,需要记录集合元素的个数,否则输出结果会出现数据越界现象。
    (2)实验内容
    通过键盘,分别输入两个数据元素类型为正整数的集合A和B,以负数输入为结束条件,输出两个集合的交、并、差。
    (3)实验要求
    从程序完善性上考虑,集合元素输入时,要有检查元素重复的功能,每个集合中不允许有重复的元素。集合可以用数组也可以用链表存储。
    实现交、并、差运算时,分别把代码写成函数的形式,即实现交运算的函数,实现并运算的函数,实现差运算的函数,在主函数中分别调用三个函数。
    使用菜单形式对应各个操作,应允许用户反复查看结果,想结束程序时,输入负数结束,使其编成一个完整的小软件。菜单参考示例如下:
    1—输入集合A和B
    2—求集合A交B
    3—求集合A并B
    4—求集合A-B
    退出,输入一个负数!
    (4)验收/测试用例
    输入: A={1,2,3,4,5} B={3,4,5,6,7}
    要注意输入的过程中,每输入一个元素都要检查输入的这个元素是否和前面的元素重复,如果重复,要求用户重新输入当前元素。
    验收测试时要测试这种重复的情况。
    输出 A交B={3, 4, 5}
    A并B={1,2,3,4,5,6,7}
    A-B={1, 2}


    一丶使用静态数组全局声明,给定数组足够的初始长度,默认里面的元素为0.

    #include<iostream>
    #include<cstring>
    #include<stdlib.h>
    using namespace std;
    //先定义两个长度足够的默认数组. 
    int a[100]={0};
    int b[100]={0};
    
    //记录集合的长度 
    int a_len=0;
    int b_len=0;
    
    
    void input_a();//输入集合A
    void input_b();//输入集合B
    void inter_(); //交集
    void union_(); //并集
    void diff_();  //A-B
    
    
    int main(){
    	int flag=1;
    	int infer;
    	while(flag){
    		cout<<"********************************"<<endl;
        	cout<<"********1:输入集合A和B**********"<<endl;
        	cout<<"********2:A与B的交集.***********"<<endl;
        	cout<<"********3:A与B的并集.***********"<<endl;
        	cout<<"********4.A与B的差集.***********"<<endl;
        	cout<<"********************************"<<endl;
    	    cout<<"输入随机一个负数来结束本程序."<<endl;
    	    cout<<"输入相应的数字,来执行相应的操作:"<<endl; 
    	    cin>>infer;
    	    switch(infer){
    	    	case 1:
    	    		int k;
    	    		k=1;
    	    		system("cls");
    	    		input_a();
    	    		for(int i=0;i<a_len-1;i++){    //每个元素依次和他后面的元素比较
    	    			for(int j=i+1;j<a_len;j++){
    	    				if(a[i]==a[j]){
    	    					cout<<"请不要输入重复整数,重新输入."<<endl;
    	    					k=0;
    						}
    					}
    				}
    				if(k==0) break;
    	    		input_b();
    	    		for(int i=0;i<b_len-1;i++){
    	    			for(int j=i+1;j<b_len;j++){
    	    				if(b[i]==b[j]){
    	    					cout<<"请不要输入重复整数,重新输入."<<endl;
    	    					k=0;
    						}
    					}
    				}
    				if(k==0) break;
    	    		break;
    	    	case 2:
    	    		system("cls");
    	    		cout<<"交集为:"; 
    	    		inter_();
    	    		break;
    	    	case 3:
    	    		system("cls");
    	    		cout<<"并集为:";
    	    		union_();
    	    		break;
    	    	case 4:
    	    		system("cls");
    	    		cout<<"A-B为:";
    	    		diff_();
    	    		break;
    	    	default:
    	    		system("cls");
    	    		if(infer<0){
    	    			flag=0;
    	    			cout<<"程序退出成功!"<<endl;
    	    			break;
    	    		}
    	    		else cout<<"您输入的指令有误,请重新输入!"<<endl;
    	    }
    	}
    	return 0;
    }
    
    
    void input_a(){    //相当于对数组中的元素复写
    	int i;
    	cout<<"请输入数值于数组a中(以输入负数为结束的标志):";
    	for(i=0;a[i]>=0;i++){
    		cin>>a[i];
    		/*for(int j=0;j<i;j++){
    			if(a[i]==a[j]){
    				cout<<"输入的数与之前相同,请重新输入."<<endl;
    				return;
    			}
    		}*/
    		if(a[i]<0) break;
    	}
    	cout<<"集合a输入完毕!"<<endl;
    	a_len=i;   //实用元素的长度
    }
    
    void input_b(){
    	cout<<"请输入数值于数组b中(以输入负数为结束的标志):";
    	int i;
    	for(i=0;b[i]>=0;i++){
    		cin>>b[i];
    		/*for(int j=0;j<i;j++){
    			if(b[i]==b[j]){
    				cout<<"输入的数与之前相同,请重新输入."<<endl;
    				return;
    	        }
    	    }*/
    	    if(b[i]<0) break;
    	}
    	cout<<"集合b输入完毕!"<<endl;
    	b_len=i;
    }
    
    void inter_(){
    	for(int i=0;i<a_len;i++){
    		for(int j=0;j<b_len;j++){
    			if(a[i]==b[j]){
    				cout<<" "<<a[i];
    			}
    		}
    	}
    	cout<<endl;
    }
    
    void union_(){   //先将A中元素输出,在B中找到与之不同的再输出
    	for(int i=0;i<a_len;i++){
    		cout<<" "<<a[i];
    	} 
    	//下面的一遍历多建议多看 
    	int transfer; 
    	for(int i=0;i<b_len;i++){
    		transfer=1;
    		for(int j=0;j<a_len;j++){
    			if(b[i]==a[j]){
    				transfer=0;
    				break;	
    			}
    		}
    		if(transfer==1){
    			cout<<" "<<b[i];
    		}	
    	}
    	cout<<endl; 
    }
    
    void diff_(){
    	int transfer;
    	for(int i=0;i<a_len;i++){
    		transfer=1;
    		for(int j=0;j<b_len;j++){
    			if(a[i]==b[j]){
    				transfer=0;
    				break;
    			}
    		}
    		if(transfer==1)
    		cout<<a[i]<<" ";
    	}
    	cout<<endl;
    }
    

    二丶利用了动态数组的方式,传参相对比较麻烦,但是节省内存有借鉴,写的不好,记录一下)
    代码如下

    #include <iostream>
    #include<stdlib.h>
    using namespace std;
    int inter_(int*A,int*B,int m,int n){   //交集 
    	int length=m>n?m:n;
    	int*size=(int*)malloc(sizeof(int)*length);
    	int c=0;
    	for(int i=0;i<m;i++){
    		for(int j=0;j<n;j++){
    			if(A[i]==B[j]){
    				size[c++]=A[i];
    			}
    		}
    	}
    	length=c;
    	cout<<"输出A与B的交集:"<<endl;
    	for(int i=0;i<length;i++){
    		cout<<size[i]<<" ";
    	}
    	cout<<endl;	
    }
    int union_(int*A,int*B,int m,int n){   //并集 
    	int len=m,judge=1;
    	int*size=(int*)malloc(sizeof(int)*(m+n));
    	for(int i=0;i<m;i++){
    		size[i]=A[i];
    	}
    	for(int i=0;i<n;i++){
    		judge=1;
    		for(int j=0;j<m;j++){
    			if(B[i]==size[j]){
    				judge=0;
    			}
    		}
    		if(judge){
    			size[len]=B[i];
    			len++;
    		}
    	}
    	cout<<"输出A与B的并集:"<<endl;
    	for(int i=0;i<len;i++){
    		cout<<size[i]<<" ";
    	}
    }
    int differ_(int*A,int*B,int m,int n){   //差集 
    	for(int i=0;i<m;i++){
    		for(int j=0;j<n;j++){
    			if(A[i]==B[j]){
    				break;
    			}
    			if(j==n-1){
    				cout<<A[i]<<" ";
    			}
    		}
    	}
    	cout<<endl;	
    }
    	
    
    	
    
    
    int main(){
            int m,n; //集合中元素的个数
    	    cout<<"输入集合A的长度:";
           	cin>>m;
    		cout<<"输入集合B的长度:";
    		cin>>n;
    		int A[m];     //不推荐这样定义
    		int B[n];
    		int due;
    		due=1;
    	while(due>0){
        	cout<<"********************************"<<endl;
        	cout<<"********1:输入集合A和B**********"<<endl;
        	cout<<"********2:A与B的交集.***********"<<endl;
        	cout<<"********3:A与B的并集.***********"<<endl;
        	cout<<"********4.A与B的差集.***********"<<endl;
        	cout<<"********************************"<<endl;
    	    cout<<"输入随机一个负数来结束本程序."<<endl;
    	    cout<<"输入相应的数字,来执行相应的操作:"<<endl; 
        	cin>>due;
    	    if(due==1){
    			cout<<"输入集合A:"<<endl;
    			int i;
    			for(i=0;i<m;i++){
    			cin>>A[i];
    			} 
    			cout<<"输入集合B:"<<endl;
    			for(i=0;i<n;i++){
    			cin>>B[i];
    			}
    			for(i=0;i<m-1;i++){            //查重 
    				for(int x=i+1;x<m;x++)
    					if(A[i]==A[x]){
    						cout<<"请不要输入重复整数,请重新输入.";
    						break;
    					}
    			for(i=0;i<m-1;i++){
    				for(int x=i+1;x<m;x++)
    					if(B[i]==B[x]){
    						cout<<"请不要输入重复整数,请重新输入.";
    						break;
    					}
    		}
    			cout<<endl;
    			cout<<endl;
         }
        }  
    	    if(due==2){
    			inter_(A,B,m,n);
    			cout<<endl;
    	}
    	    if(due==3){
    			union_(A,B,m,n);
    			cout<<endl;
    	}
            if(due==4){
            	cout<<endl;
            	cout<<endl;
    			differ_(A,B,m,n);
    			cout<<endl;
    		}
    		if(due>4){
    			cout<<"请按操作提示输入,不要乱输."; 
    			cout<<endl;
    			cout<<endl;
    		}
    	
    }
        cout<<"结束本程序";
    	return 0;
    }
    在这里插入代码片
    
    展开全文
  • 数据结构集合运算。 数据结构集合运算。
  • 至少应包括初始化,用尾插法建立集合,查找给定元素是否在集合内,将新元素插入集合中,删除集合中指定元素,求两个集合、输出等操作的实现。 要求设计一个主程序,首先定义3个用有序单链表实现的集合A...

    题目

    编写一组程序,用带头结点的有序单链表实现一个集合,放在“SetList. h"中。要求实现这个集合的结构和相关的操作。至少应包括初始化,用尾插法建立集合,查找给定元素是否在集合内,将新元素插入集合中,删除集合中指定元素,求两个集合的并、交、差、输出等操作的实现。
    要求设计一个主程序,首先定义3个用有序单链表实现的集合A、B、C并初始化为空集合,其元素的数据类型为整型;再依次读入若干整数创建一个集合A和B,并检查集合上的查找、插入、删除等操作的实现,存入C中并输出它。

    实现

    //main.cpp
    #include "SetList.h"
    int main()
    {
        linklist A,B,C;
        init(A);init(B);init(C);
        
    	cout<<"创建A集合:"<<"\n";
    	cout<<"请输入A的终止输入标志:"<<"\n";
    	int end;
    	cin>>end;
    	build(A,end);
    	
    	cout<<"创建B集合:"<<"\n";
    	cout<<"请输入B的终止输入标志:"<<"\n";
    	int endb;
    	cin>>endb;
    	build(B,endb);
    	
    	cout<<"请选择相关操作:1-查找,2-插入,3-删除,0-结束:"<<"\n";
    	int key;
    	cin>>key;
    	
    	while(key)
    	{
    	switch(key)
    	{
    		case 1:{
    			cout<<"请输入操作的对象,1-A,2-B:"<<"\n";
    			int m;
    			cin>>m;
    			cout<<"请输入需要查找的值"<<"\n";
    			int n;
    			cin>>n;
    			if(m==1)
    			{
    				if(find(A,n)==-1)
    					cout<<"未找到!"<<"\n";
    				else
    					cout<<"位置是:"<<find(A,n)<<"\n"; 
    			} 
    			else
    			{
    				if(find(B,n)==-1)
    					cout<<"未找到!"<<"\n";
    				else
    					cout<<"位置是:"<<find(B,n)<<"\n"; 
    			} 
    			break;
    		}
    		case 2:{
    			cout<<"请输入操作的对象,1-A,2-B:"<<"\n";
    			int m;
    			cin>>m;
    			cout<<"请输入要插入的值"<<"\n";
    			int n;
    			cin>>n;
    			cout<<"请输入要插入的位置"<<"\n";
    			int k;
    			cin>>k;
    			if(m==1)
    				insert(A,k,n);
    			else
    				insert(B,k,n);
    			break;
    		}
    		case 3:{
    			cout<<"请输入操作的对象,1-A,2-B:"<<"\n";
    			int m;
    			cin>>m;
    			cout<<"请输入要删除的位置"<<"\n";
    			int k;
    			cin>>k;
    			if(m==1)
    				remove(A,k);
    			else
    				remove(B,k);
    			break;
    		}
    		default :break;
    	}
    	cout<<"请选择相关操作:1-查找,2-插入,3-删除,0-结束:"<<"\n";
    	cin>>key;
    	}
    	cout<<"得到C:"<<"\n"; 
    	bing(A,B,C);
    	print(C);
        return 0;
    }
    
    //SetList.h
    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    using namespace std;
    
    typedef int type;
    typedef struct node{                                        
        type data;                                          
        struct node *link;                                      
    }node,*linklist;  
                                          
    void init(linklist& S){ //初始化                             
        S = (node*) malloc(sizeof (node));             
        S->link = NULL;                                 
    }
    
    void build( linklist& first, type end )//尾插法构建链表 
    {
        type val;  
        node *s, *rear = first;
        cout<<"请输入数据:"<<"\n";
    	cin>>val;
        while ( val != end) {
            s = (node *) malloc ( sizeof (node ));
            s->data = val;  		
            rear->link = s;   rear = s;	
            cout<<"请输入数据:"<<"\n";
            cin>>val;	   
        }
        rear->link = NULL;		
    } 
    int find ( linklist & first, type x ) //寻找
    {
    	int i=1;
        node * p = first->link;        
        while (p!= NULL)  
        {if(p->data == x) return i;
    	p = p->link;
        i++;
    	}
        return 0;     
    }
    
    
    void print(linklist& first ) {	//输出链表
        first=first->link;
    	while(first)
            {cout<<first->data<<"\n";
            first=first->link ;
    		}
        cout<<"\n";
    }
    void insert( linklist& first, int i, type x ) {//插入
    	if(i<1) cout<<"插入失败"<<"\n"; 
        node *newnode;
        newnode = (node *) malloc (sizeof (node));
    	newnode->data = x;
        node *p = first, *pr;   int k = 0;
        while ( p != NULL && k < i-1 ) 
            { pr = p;  p = p->link;  k++; } 
    	if ( p == NULL && first != NULL ) 
    		p = pr;
        newnode->link = p->link;
        p->link = newnode;
        cout<<"插入成功"<<"\n"; 						
    } 
    
    bool remove(linklist& first,  int i) //删除
    {
        node *p, *q;   int k;
        if ( i == 0 ) return false;    
        else 
    	{			     
            p = first;  int k = 0;        
            while ( p != NULL && k < i-1 )
                    { p = p->link; k++; }
    		if ( p == NULL || p->link == NULL ) 
    			{
                cout<< "无效的删除位置!"<<"\n";
                return false;	    
          		}
          	else {                         	    
                q = p->link;       	    
                p->link = q->link;        
          		}
            free (q);   
        }
          return true; 
    }
    
    void insertA(linklist &first , type x)//在结尾插入
    {
    	node *newnode;
        newnode = (node *) malloc (sizeof (node));
    	newnode->data = x;
        node *p = first, *pr;   
        while ( p != NULL  ) 
            { pr = p;  p = p->link; } 
    	if ( p == NULL && first != NULL ) 
    		p = pr;
        newnode->link = p->link;
        p->link = newnode;
    }
    
    
    void bing(linklist &a, linklist &b, linklist& c)//并
    { 
    	a = a->link;
    	b = b->link;
    	while (a)
    	{
    		if (!find(c,a->data))
    		{
    			insertA(c, a->data);
    		}
    		a = a->link;
    	}
    	while (b)
    	{
    		if (!find(c,b->data))
    		{
    			insertA(c, b->data);
    		}
    		b = b->link;
    	}
    }
      
    void jiao(linklist &L1, linklist &L2, linklist& L3)//交
    {
    	L1 = L1->link;
    	L2 = L2->link;
    	while (L1)
    	{
    		if (find(L2,L1->data))
    		{
    			insertA(L3, L1->data);
    		}
    		L1 = L1->link;
    	}
    }
    void cha(linklist &L1, linklist &L2, linklist& L3)//差
    {
    	L1 = L1->link;
    	L2 = L2->link;
    	while (L1)
    	{
    		if (!find(L2,L1->data))
    			insertA(L3, L1->data);
    		L1 = L1->link;
    	}
    }
    
    展开全文
  • 集合并交运算 1.问题描述 编制一个能演示执行集合并交运算的程序 要求 集合的元素限定为小写字母字符[a.z] 演示程序以用户和计算机的对话方式执行 实现提示以链表表示集合 选作内容 集合的元素判定和...
  • # 数据结构实验1 集合 ## 一、实验内容 (1)实验目的 通过该实验,让学生复习巩固C语言中的循环结构、循环控制条件、分支结构和数组/链表、函数的调用等有关内容,体会到用数组存储集合时,需要记录...

    数据结构实验1  集合的交、并、差

    一、实验内容

    (1)实验目的

    通过该实验,让学生复习巩固C语言中的循环结构、循环控制条件、分支结构和数组/链表、函数的调用等有关内容,体会到用数组存储集合时,需要记录集合元素的个数,否则输出结果会出现数据越界现象。 

    (2)实验内容

    通过键盘,分别输入两个数据元素类型为正整数的集合A和B,以负数输入为结束条件,输出两个集合的交、并、差。

    (3)实验要求

    从程序完善性上考虑,集合元素输入时,要有检查元素重复的功能,每个集合中不允许有重复的元素。集合可以用数组也可以用链表存储。

    实现交、并、差运算时,分别把代码写成函数的形式,即实现交运算的函数,实现并运算的函数,实现差运算的函数,在主函数中分别调用三个函数。

    使用菜单形式对应各个操作,应允许用户反复查看结果,想结束程序时,输入负数结束,使其编成一个完整的小软件。

    (4)验收/测试用例

    输入: A={1,2,3,4,5}        B={3,4,5,6,7}

    要注意输入的过程中,每输入一个元素都要检查输入的这个元素是否和前面的元素重复,如果重复,要求用户重新输入当前元素。

    验收测试时要测试这种重复的情况。

    输出 A交B={3, 4, 5} , A并B={1,2,3,4,5,6,7} , A-B={1, 2}。

    菜单示例:

    1---输入集合A和B

    2---求集合A交B

    3---求集合A并B

    4---求集合A-B

    5---输出集合A,B

       退出,输入一个负数!

    二、运行效果截图

    三、代码实现

    #include<iostream>
    #include<stdlib.h>
    #include<stdio.h>
    using namespace std;
    
    int jiheA();
    int jiheB();
    int jiao();
    int bing();
    int cha();
    
    int shuzuA[100];//定义全局变量,数组A 
    int shuzuB[100];//数组B 
    int i=0;//数组A的元素下标 
    int m=0;//数组B的元素下标 
    
    int main()
    {
    int n=1;
    while(n)
    {
    	int select;
    	cout<<"author---Henan University.software engineering.李思佳"<<endl;
    	cout<<"1---输入集合A和B"<<endl;
    	cout<<"2---求集合A交B"<<endl;
    	cout<<"3---求集合A并B"<<endl;
    	cout<<"4---求集合A-B"<<endl;
    	cout<<"5---输出集合A,B"<<endl;
    	cout<<"退出,输入一个负数!"<<endl;
    	cout<<"请输入指令:";
    	cin>>select; 
    
    switch(select)
    {
    	case 1:
    		system("cls");
    		cout<<"请输入集合A和B"<<endl;
    		jiheA();
    		jiheB();
    		break;
    	case 2:
    		system("cls");
    		cout<<"集合A交B为:"<<endl;
    		jiao();
    		break;
    	case 3:
    		system("cls");
    		cout<<"集合A并B为:"<<endl;
    		bing();
    		break;
    	case 4: 
    	    system("cls");
    	    cout<<"集合A-B为:"<<endl;
    	    cha();
    	    break;
    	case 5: 
    	    system("cls");
    	    cout<<"集合A为:"<<endl;
    	    for(int k=0;k<i;k++)
    	    {
    	    	cout<<shuzuA[k]<<" ";
    		}
    		cout<<endl;
    		cout<<"集合B为:"<<endl;
    		for(int k=0;k<m;k++)
    	    {
    	    	cout<<shuzuB[k]<<" ";
    		}
    		cout<<endl;
    		cout<<endl;
    	    break;
    	    
    	default:
    		system("cls");
    		if(select<0)
    		{
    			n=0;
    		    cout<<"已经退出程序,欢迎下次使用!"<<endl;
    		    break;
    		}
    }
    
    }
    
    	return 0;
    }
    
    //输入集合A 
    int jiheA()
    {
    	int num;
    	cout<<"请输入集合A,直到输入一个负数为止:"<<endl;
    	while(scanf("%d",&num)>0 && getchar()!='\n')
    	{	
    		i++;	    
    	    if(i==1)	
    		{
    		    shuzuA[0]=num;
    		}	
    					
    		else
    		{	
    		    for(int j=0;j<=i-2;j++)
    		    {
    			    if(num!=shuzuA[j])
    		        {
    				shuzuA[i-1]=num;
    		    	}
    		    	else
    		    	{
    		        cout<<"输入元素重复,请重新输入集合A!"<<endl; 
    		        cout<<endl;
    		        i=0;
    		        jiheA();
    				}			
    		    }					
    		}			
    	}
    }
    
    //输入集合B 
    int jiheB()
    {
        int num;
    	cout<<"请输入集合B,直到输入一个负数为止:"<<endl;
    	while(scanf("%d",&num)>0 && getchar()!='\n')
    	{	
    		m++;	    
    	    if(m==1)	
    		{
    		    shuzuB[0]=num;
    		}						
    		else
    		{	
    		    for(int j=0;j<=m-2;j++)
    		    {
    			    if(num!=shuzuB[j])
    		        {
    				shuzuB[m-1]=num;
    		    	}
    		    	else
    		    	{
    		        cout<<"输入元素重复,请重新输入集合B!"; 
    		        m=0;
    		        jiheB();
    				}			
    		    }					
    		}			
    	}	
    	cout<<endl;
    }
    
    //交函数 
    int jiao()
    {
    	
    	for(int k=0;k<i;k++)
    	{
    		for(int j=0;j<m;j++)
    		{
    			if(shuzuA[k]==shuzuB[j])
    			{
    			cout<<shuzuA[k]<<" ";
    			break;
    			}
    		}
    	}
    	
    	cout<<endl;cout<<endl;
    }
    
    //并函数 
    int bing()
    {
    	int t=0;
    	for(int k=0;k<i;k++)
    	{
    	    cout<<shuzuA[k]<<" ";
    	}
    	
    	for(int j=0;j<m;j++)
    	{
    		for(int k=0;k<i;k++)
    		{
    			if(shuzuB[j]!=shuzuA[k])
    			{
    				t++;
    			}
    		}
    		
    		if(t==i)
    		{
    			cout<<shuzuB[j]<<" ";			
    		}
    		t=0;
    	}		
    	cout<<endl;	cout<<endl;
    }
    //差函数 
    int cha()
    {
    	int t=0;
    	for(int j=0;j<i;j++)
    	{
    		for(int k=0;k<m;k++)
    		{
    			if(shuzuA[j]!=shuzuB[k])
    			{
    				t++;
    			}
    		}
    		if(t==m)
    		{
    		    cout<<shuzuA[j]<<" ";
    		}
    		t=0;
    	}
    	
    	cout<<endl;cout<<endl;
    }
    

     

     

    展开全文
  • 实习报告 题目编制一个演示集合并交运算的程序 班级 95001 姓名 张三 学号9500101完成日期 2008-6-16 一需求分析 1. 本程序中集合的元素限定为小写字母字符 ['a'z']集合的大小n集合输入的形式为一个以"回车符...
  • (C++)数据结构实验(1) —— 用链表实现集合交并差

    (C++)数据结构实验(1) —— 用链表实现集合的交并差

    第二版

    增加了从txt中读取内容。

    #include <iostream>
    #include <string>
    using namespace std;
    #include <fstream>
    #define BOX 100
    #define  TRUE 1
    #define  FALSE 0
    
    
    //可以用于类似于检测卷面相似度 或者 答题卡答案的比对
    struct LNode
    {
    	char data;
    	struct LNode* next;
    };
    LNode* createList()
    {
    	int n;
    	int i = 0;
    	LNode* head = new LNode;
    	//在堆上生成,函数结束后才可以保存
    	LNode* pre = head;
    	cout << "请输入字符串的字母个数" << endl;
    	cin >> n;
    	
    	while(n <= 0)
    	{
    		cout << "请输入一个大于零的数" << endl;
    	    	cin >> n;
        }
           
        
           	 cout << "请输入字符串" << endl;
           	
      
    	for (int i = 0; i < n; i++)
    	{
    		LNode* p = new LNode;
    
    		cin >> p->data;
    		if (p->data >= 97 && p->data <= 122)
    		{
    			pre->next = p;
    			pre = p;
    			p->next = NULL;
    		}
    		else 
    		{
    			cout << "请输入小写英文字母\n";
    			i--;
    		}
    	}
    	return head;
    }
    //遍历单链表函数
    void display(LNode* head)
    {
    	LNode* p = head->next;
    
    	while (p != NULL)
    	{
    		cout << p->data;
    		p = p->next;
    		cout << "  ";
    	}
    	cout << endl;
    }
    //排序
    void sort(LNode* head)
    {
    	LNode* cur = NULL;
    	LNode* tag = NULL;
    
    	cur = head;
    
    	while (cur != tag)
    	{
    		while (cur->next != tag)
    		{
    			if (cur->data > cur->next->data)
    			{
    				char tmp = cur->data;
    				cur->data = cur->next->data;
    				cur->next->data = tmp;
    			}
    			cur = cur->next;
    		}
    		tag = cur;
    		cur = head;
    	}
    
    }
    //消除相同元素
    void erase(LNode* head)
    {
    	LNode* p = head->next;
    	if (!p)
    		return;
    	while (p != NULL)
    	{
    		LNode* q = p;
    		LNode* temp;
    		while (q != NULL && q->next != NULL)
    		{
    			if (q->next->data == p->data)
    			{
    				temp = q->next;
    				q->next = temp->next;
    				delete temp;
    			}
    			else q = q->next;
    		}
    		p = p->next;
    	}
    }
    //求交集
    void JiaoJi(LNode* head1, LNode* head2)
    {
    	LNode* p = head1->next;
    	LNode* q = head2->next;
    
    	while (p != NULL && q != NULL)
    	{
    		if (p->data == q->data)
    		{
    			cout << p->data << "  ";
    			q = q->next;
    			p = p->next;
    		}
    		else if (p->data < q->data)
    		{
    			p = p->next;
    		}
    		else if (p->data > q->data)
    		{
    			q = q->next;
    		}
    	}
    
    }
    //求并集
    void BingJi(LNode* head1, LNode* head2)
    {
    	LNode* p = head1->next;
    	LNode* q = head2->next;
    
    	while (p != NULL && q != NULL)
    	{
    		if (p->data < q->data)
    		{
    			cout << p->data << "  ";
    			p = p->next;
    		}
    		else if (p->data > q->data)
    		{
    			cout << q->data << "  ";
    			q = q->next;
    		}
    		else if (p->data == q->data)
    		{
    			cout << p->data << "  ";
    			q = q->next;
    			p = p->next;
    		}
    	}
    	while (p != NULL)
    	{
    		cout << p->data << "  ";
    		p = p->next;
    	}
    	while (q != NULL)
    	{
    		cout << q->data << "  ";
    		q = q->next;
    	}
    }
    //求差集
    void ChaJi(LNode* head1, LNode* head2)
    {
    	LNode* p = head1->next;
    	LNode* q = head2->next;
    
    	while (p != NULL && q != NULL)
    	{
    		if (p->data < q->data)
    		{
    			cout << p->data << "  ";
    			p = p->next;
    		}
    		else if (p->data > q->data)
    		{
    			cout << q->data << "  ";
    			q = q->next;
    		}
    		else if (p->data == q->data)
    		{
    			q = q->next;
    			p = p->next;
    		}
    	}
    	while (p != NULL)
    	{
    		cout << p->data << "  ";
    		p = p->next;
    	}
    	while (q != NULL)
    	{
    		cout << q->data << "  ";
    		q = q->next;
    	}
    }
    void CompareText(LNode* head1, LNode* head2)
    {
    	LNode* m = head1->next;
    	LNode* n = head2->next;
    	int num1 = 0;
    	int num2 = 0;
    	char p[BOX] = { NULL };
    	char q[BOX] = { NULL };
    
    	//读取第一个文件的内容存储到数组p中,再存到链表中
    	ifstream first("answer.txt", ios::in);
    	if (!first.is_open())
    	{
    		cout << "Error: opening file fail" << endl;
    		system("pause");
    		exit(1);
    	}
    	while (!first.eof() && num1 < BOX)
    	{
    		first >> p[num1];
    		num1++;
    	}
    	cout << "标准答案为:" << endl;
    	for (int i = 0; p[i] != NULL; ++i)
    	{
    		cout << p[i] << " ";
    	}
    	first.close();
    
    	for (int i = 0; i < BOX; i++)
    	{
    		LNode* x = new LNode;
    		x->data = p[i];
    		head1->next = x;
    		head1 = x;
    		x->next = NULL;
    		if (x->data == NULL)
    		{
    			break;
    		}
    	}
    	cout << endl;
    	cout << endl;
    	//读取第二个文件的内容存储到数组q中,再存到链表中
    	ifstream second("paper.txt", ios::in);
    	if (!second.is_open())
    	{
    		cout << "Error: opening file fail" << endl;
    		system("pause");
    		exit(1);
    	}
    	while (!second.eof() && num2 < BOX)
    	{
    		second >> q[num2];
    		num2++;
    	}
    
    	for (int i = 0; q[i] != NULL; ++i)
    	{
    
    		if (i % 10 == 0 && i != 0)
    		{
    			cout << endl;
    		}
    
    		cout << q[i] << " ";
    	}
    	second.close();
    
    	for (int i = 0; i < BOX; i++)
    	{
    		LNode* x = new LNode;
    		x->data = q[i];
    		head2->next = x;
    		head2 = x;
    		x->next = NULL;
    		if (x->data == NULL)
    		{
    			break;
    		}
    	}
    	cout << endl;
    }
    void OutPutScore(LNode* head1, LNode* head2)
    {
    	LNode* temp = head1->next;
    	LNode* p = head1->next;
    	LNode* q = head2->next;
    
    	int ture = 0;
    	int fullScore = 0;
    	float score = 0.0;
    	int i = 0;
    	string nameSeed = "ABCDEFGHIJ";
    
    	while (q->next != NULL)
    	{
    		while (p->next != NULL && q != NULL)
    		{
    			if (p->data == q->data)
    			{
    				q = q->next;
    				p = p->next;
    				ture++;
    				fullScore++;
    			}
    			else
    			{
    				q = q->next;
    				p = p->next;
    				fullScore++;
    			}
    		}
    		cout << "学生"<<nameSeed[i]<<"的分数是:" << ture*10 << endl;
    		i++;
    		ture = 0;
    		fullScore = 0;
    		p = temp;
    	}
    }
    //求补集
    void BuJi(LNode* head1, LNode* head2) {
    	LNode* p = head1->next;
    	LNode* q = head2->next;
    
    	while (p != NULL && q != NULL)
    	{
    		if (p->data < q->data)
    		{
    			cout << p->data << " 为q补集 "<<endl;
    			p = p->next;
    		}
    		else if (p->data > q->data)
    		{
    			cout << q->data << " 为p补集 "<<endl;
    			q = q->next;
    		}
    		else if (p->data == q->data)
    		{
    			q = q->next;
    			p = p->next;
    		}
    	}
    	while (p != NULL)
    	{
    		cout << p->data << " 为q补集  "<<endl;
    		p = p->next;
    	}
    	while (q != NULL)
    	{
    		cout << q->data << " 为p补集  "<<endl;
    		q = q->next;
    	}
    }
    
    //判断是否是子集
    int Judge(LNode* head1, LNode* head2) {
    
    	LNode* p = head1->next;
    	LNode* q = head2->next;
    	int k = 0; int a = 0; int b = 0;              //k记录当前的数相同的数目 a,b记录p,q长度 
    
    	while (p != NULL && q != NULL)
    	{
    		if (p->data < q->data)
    		{
    			p = p->next;
    			//	break;
    		}
    		else if (p->data > q->data)
    		{
    			q = q->next;
    		}
    		//	break;
    
    		else if (p->data == q->data)
    		{
    			q = q->next;
    			p = p->next;
    			k++;
    			//		break;
    		}
    	}
    	p = head1->next;
    	q = head2->next;
    	while (p) {
    		a++;
    		p = p->next;
    	}
    	while (q)
    	{
    		b++;
    		q = q->next;
    	}
    	 if(k < a&&k < b){ 
        return FALSE;
    	}else{
    		if(a < b){
    			cout<<"p是q的子集"<<endl;
    		}else if(a > b){
    			cout<<"q是p的子集"<<endl;
    		}else{
    			cout<<"p,q互为真子集"<<endl;
    		}
    	return TRUE;
    	}
    }
    int main()
    {
    
    
    	while (1)
    	{
    		int choice;
    		cout << "——————————————————————" << endl;
    		cout << endl;
    		cout << "	请输入对应数字以执行操作:" << endl;
    		cout << "	  1.执行AB取并集操作" << endl;
    		cout << "	  2.执行AB取交集操作" << endl;
    		cout << "	  3.执行AB作差操作" << endl;
    		cout << "	  4.读取标准答案以及学生答案并输出成绩" << endl;
    		cout << "	  5.执行AB取补集操作" << endl;
    		cout << "	  6.判断AB是否为子集关系" << endl;
    		cout << endl;
    		cout << "——————————————————————" << endl;
    		cin >> choice;
    
    		switch (choice)
    		{
    		case 1:
    		{
    			LNode* La = createList();
    			LNode* Lb = createList();
    
    			sort(La);
    			sort(Lb);
    
    			erase(La);
    			erase(Lb);
    
    			BingJi(La, Lb);
    
    			system("pause");
    			getchar();
    			system("cls");
    			break;
    		}
    		case 2:
    		{
    			LNode* La = createList();
    			LNode* Lb = createList();
    
    			sort(La);
    			sort(Lb);
    
    			erase(La);
    			erase(Lb);
    
    			JiaoJi(La, Lb);
    
    			system("pause");
    			getchar();
    			system("cls");
    			break;
    		}
    		case 3:
    		{
    			LNode* La = createList();
    			LNode* Lb = createList();
    
    			sort(La);
    			sort(Lb);
    
    			erase(La);
    			erase(Lb);
    
    			ChaJi(La, Lb);
    
    			system("pause");
    			getchar();
    			system("cls");
    			break;
    		}
    		case 4:
    		{
    			LNode* La = new LNode;
    			LNode* Lb = new LNode;
    
    			CompareText(La, Lb);
    			OutPutScore(La, Lb);
    
    			system("pause");
    			getchar();
    			system("cls");
    			break;
    		}
    		case 5:
    		{
    			LNode* La = createList();
    			LNode* Lb = createList();
    
    			sort(La);
    			sort(Lb);
    
    			erase(La);
    			erase(Lb);
    
    			BuJi(La, Lb);
    
    			system("pause");
    			getchar();
    			system("cls");
    			break;
    		}
    		case 6:
    		{
    			LNode* La = createList();
    			LNode* Lb = createList();
    
    			sort(La);
    			sort(Lb);
    
    			erase(La);
    			erase(Lb);
    
    			Judge(La, Lb);
    			
    			if(Judge(La,Lb)) 
    			{
    				//cout<<"存在子集关系"<<endl;
    				
    			}
    			else if(!Judge(La,Lb))
    			{
    				cout<<"不存在子集关系"<<endl;
    			}
    
    			system("pause");
    			getchar();
    			system("cls");
    			break;
    		}
    		}
    	}
    }
    
    
    展开全文
  • 数据结构严蔚敏版,是课本里出的题目的答案。内含所有代码,EXE文件等。功能可实现
  • 题目 集合并交运算 问题描述 编制一个能演示执行集合并交运算的程序 基本要求 (1) 集合的元素限定为小写字母字符 [, a. ?z?] (2) 演示程序以用户和计算机的对话方式执行 测试数据 (1)Set1="magazine" ...
  • 大数据量的 去重、交并差.....等集合操作,都可以适当借助中间容器实现,并且合理运用不同的数据结构的特点做中间容器,可以大大提高效率优化时间复杂度。尽可能避免循环嵌套的遍历,造成倍数级别(n行x ...
  • 实验一集合交并差.zip

    2019-11-04 13:44:49
    数据结构集合的交叉实验,用vs平台打开,内涵实验原理及过程的实验报告和ppt.
  • 通过键盘,分别输入两个数据元素类型为正整数的集合A和B,以负数输入为结束条件,输出两个集合。从程序完善性上考虑,集合元素输入时,要有检查元素重复的功能。集合可以用数组也可以用链表存储。 二. ...
  • 集合交并差运算

    2012-04-24 13:32:32
    C语言 数据结构 完成连队列的 集合 运算
  • 集合交并差运算

    2018-11-17 23:14:49
    数据结构集合交并差运算,使用C++实现,并且设置了良好的界面
  • 西安建筑科技大学华清学院 课程设计论文 题 目 院 系 ...数据结构是实践很强的课程课程设计是加强学生实践能力的一个强有力的手 段课程设计要求我们完成程序设计的同时能够写出比较规范的设计报告严格实 施课程设计这
  • if(c.elem[i]==c.elem[i+1])//删除集合中相同的元素 continue; else printf("%d ",c.elem[i]); } printf("\n"); } //求a和b的并集 int unionList(Sqlist &a,Sqlist &b,Sqlist &c) { int i=0,j=0,k=0; c.length=a....
  • 集合(用单链表表示)的运算: 问题描述:该算法的设计,要求运行结果如下所示: (包含三种排序) 集合的运算如下: 原 集 合A: c a e h 原 集 合B: f h b g d a 有序集合A: a c e h 有序集合B: a b d f g...
  • 数据结构–C语言链表实现集合的()运算!(数组) 效果如图: 要求: 从程序完善性上考虑,集合元素输入时,要有检查元素重复的功能,每个集合中不允许有重复的元素。集合可以用数组也可以用链表存储。 ...
  • 实现运算时,分别把代码写成函数的形式,即实现运算的函数,实现运算的函数,实现运算的函数,在主函数中分别调用三个函数。 使用菜单形式对应各个操作,应允许用户反复查看结果,想结束程序时,...
  • 编制一个能演示执行集合运算的程序。 【基本要求】 (1) 集合的元素限定为小写字母字符 [‘a’..’z’] 。 (2) 演示程序以用户和计算机的对话方式执行。 【测试数据】 (1)Set1="magazine",Set2=...
  • 实验 二 集合运算 //在写代码的过程中,没有注意头结点~~~ 导致出现了很多野指针~~~ ,几乎重写. 。o 0 ~~~ // 经同学检查,发现有错误~~~ 红色部分代码已经修正 //集合运算 /*选作...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 182
精华内容 72
关键字:

数据结构集合交并差

数据结构 订阅