集合的并、交运算C语言
集合的并,交运算
1：集合的并，交运算2：C语言源代码如下#include<stdio.h>#include<stdlib.h>typedefstruct node/*节点类型定义*/{char data;struct node *next;}LinkedList;void init (LinkedList *L)/*对单链表进行初始化*/{L=(LinkedList*)malloc(sizeof(LinkedList));L->next=NULL;}LinkedList *create()/*尾插发建表*/{charch;LinkedList *h,*s,*r;h=(LinkedList*)malloc(sizeof(LinkedList));r=h;ch=getchar();while(ch!='$'){s=(LinkedList*)malloc(sizeof(LinkedList));/*申请借点空间*/s->data=ch;r->next=s;r=s;ch=getchar();}r->next=NULL;return h;}void print(LinkedList *q)/*输出单链表*/{LinkedList *p;p=q->next;while(p){printf("%5c,",p->data);p=p->next;}printf("\n");}void Union(LinkedList *a,LinkedList *b, LinkedList *c)/*求并运算*/{LinkedList *p,*q,*r,*s;int f=0;r=c;for(p=a->next;p!=NULL;p=p->next){s=(LinkedList*)malloc(sizeof(LinkedList));s->data=p->data;r->next=s;r=s;s->next=NULL;}for(p=b->next;p!=NULL;p=p->next){for(q=a->next;q!=NULL;q=q->next){if(p->data==q->data){f=1;break;}}if(f==0){s=(LinkedList*)malloc(sizeof(LinkedList));s->data=p->data;r->next=s;r=s;s->next=NULL;}f=0;}}int inter(LinkedList *a,LinkedList *b,LinkedList *c)/*求交运算*/ {int re=0;LinkedList *p,*q,*r=c,*s;for(p=a->next;p!=NULL;p=p->next){for(q=b->next;q!=NULL;q=q->next){if(p->data==q->data){s=(LinkedList*)malloc(sizeof(LinkedList));s->data=p->data;r->next=s;r=s;s->next=NULL;re=1;}}}return re;}int main(intargc,char *argv[])/*主函数模块*/{LinkedList *a,*b,*jiao,*bing;printf("请输入集合A以$结束!\n");a=create();getchar();printf("请输入集合B以$结束!\n");b=create();printf("集合A为:\n");print(a);printf("集合B为:\n");print(b);jiao=(LinkedList*)malloc(sizeof(LinkedList));bing=(LinkedList*)malloc(sizeof(LinkedList));printf("交集为:\n");inter(a,b,jiao);print(jiao);printf("并集为:\n");Union(a,b,bing);print(bing);return 0;}3：输出结果如下。
C语言集合的实现
C语言集合的实现C语言是一种通用的程序设计语言，提供了丰富的数据结构和算法库。
在C语言中，集合是一种存储不重复元素的数据结构，常用于需要存储、查询和操作一组不同元素的场景。
本文将介绍C语言中集合的实现方式，并详细解释其原理和应用。
1.集合的定义集合是一种不包含重复元素的容器，没有特定的顺序。
在C语言中，可以使用数组或链表等数据结构来实现集合。
集合通常有以下几个基本操作：插入元素、删除元素、判断元素是否存在、求并集、求交集、求差集等。
2.集合的实现方式2.1使用数组实现集合使用数组实现集合比较简单，只需要定义一个固定大小的数组，然后使用元素的值作为下标来标记元素是否存在。
例如，要存储范围在0-9之间的整数集合，可以定义一个大小为10的数组，数组下标代表元素值，数组元素的值用于表示元素是否存在。
下面是使用数组实现集合的示例代码：```c#define SIZE 10//初始化集合void initSet(int set[])for (int i = 0; i < SIZE; i++)set[i] = 0;}//插入元素void insertElement(int set[], int element) if (element >= 0 && element < SIZE)set[element] = 1;}//删除元素void deleteElement(int set[], int element) if (element >= 0 && element < SIZE)set[element] = 0;}//判断元素是否存在int isElementExist(int set[], int element) if (element >= 0 && element < SIZE)return set[element];} elsereturn 0;}//打印集合void printSet(int set[])for (int i = 0; i < SIZE; i++) if (set[i] == 1)printf("%d ", i);}}int maiint set[SIZE];initSet(set);insertElement(set, 1); insertElement(set, 3); insertElement(set, 5); deleteElement(set, 3);printf("集合中的元素为："); printSet(set);return 0;```这段代码中，先定义了一个大小为10的数组作为集合的存储空间。
c语言的集合的交并补
printf("}\n");
printf("A-B={");
bianli(bu, num3);
printf("}\n");
return 0;
}
通过键盘，分别输入两个数据元素类型为正整数的集合A和B，以负数输入为结束条件，输出两个集合的交、并、差。从程序完善性上考虑，集合元素输入时，要有检查元素重复的功能。集合可以用数组也可以用链表存储。
输入： 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}
}
}
int main(){
int c;
int a[N],count1,b[N],count2;//a，b两个集合，以及数量
int jiao[N],bing[2*N],bu[N];//交并补三个集合
int num1=0,num2=0,num3=0;
printf("请输入第一个集合:\n");
for(int i=0;i<N;i++){
for(int i=0;i<=count1;i++){//用b数组遍历bing
for(int j=0;j<=count2;j++){
if(b[i]==bing[j])
break;
if(j==count2)
bing[num2++]=b[i];
}
}
//求a对b的补集
for(int i=0;i<=count1;i++){
for(int j=0;j<=count2;j++){
实现两个集合的相关运算c语言
实现两个集合的相关运算c语言实现两个集合的相关运算（C语言）在编程中，集合是一种常见的数据结构，用于存储一组不重复的元素。
集合的相关运算包括并集、交集、差集等，可以帮助我们对数据进行处理和分析。
本文将以C语言为例，介绍如何实现两个集合的相关运算。
一、集合的定义与表示在C语言中，可以使用数组来表示集合。
数组的每个元素对应集合中的一个元素，而数组的索引则代表元素的位置。
为了实现集合的相关运算，我们需要定义一个结构体来存储集合的信息，包括集合的大小和元素数组。
下面是一个示例的集合结构体定义：```c#define MAX_SIZE 100typedef struct {int size; // 集合的大小int elements[MAX_SIZE]; // 元素数组} Set;```二、集合的初始化在进行集合运算之前，我们首先需要初始化两个集合。
集合的初始化包括设置集合的大小和填充元素数组。
下面是一个示例的集合初始化函数：```cvoid initSet(Set* set, int size, int elements[]) {set->size = size;for (int i = 0; i < size; i++) {set->elements[i] = elements[i];}}```三、集合的并集运算集合的并集运算是指将两个集合中的所有元素合并成一个新的集合。
为了实现集合的并集运算，我们可以遍历其中一个集合的元素，并将其添加到另一个集合中，同时确保新集合中不包含重复的元素。
下面是一个示例的集合并集运算函数：```cSet unionSet(Set set1, Set set2) {Set resultSet;int resultSetSize = set1.size + set2.size;int resultElements[MAX_SIZE];// 将set1的元素添加到resultSet中for (int i = 0; i < set1.size; i++) {resultElements[i] = set1.elements[i];}// 遍历set2的元素，将不重复的元素添加到resultSet中 for (int i = 0; i < set2.size; i++) {int element = set2.elements[i];int isDuplicate = 0;// 检查element是否已经存在于resultSet中for (int j = 0; j < resultSetSize; j++) {if (element == resultElements[j]) {isDuplicate = 1;break;}}// 如果element不重复，则添加到resultSet中if (!isDuplicate) {resultElements[resultSetSize++] = element;}}initSet(&resultSet, resultSetSize, resultElements);return resultSet;}```四、集合的交集运算集合的交集运算是指找到两个集合中共同存在的元素。
c语言汇编指令集
c语言汇编指令集C语言汇编指令集一、引言计算机是由硬件和软件组成的，其中软件部分是由一系列指令组成的。
指令是计算机执行操作的基本单位，而汇编指令集就是这些指令的集合。
C语言是一种高级编程语言，但在底层，C语言也可以通过汇编指令集来直接操作计算机硬件。
本文将介绍C语言汇编指令集的一些常用指令。
二、数据传输指令数据传输指令是用来在寄存器和内存之间传输数据的指令。
常用的数据传输指令有MOV、LDR、STR等。
MOV指令用于将数据从一个寄存器传输到另一个寄存器；LDR指令用于将数据从内存中加载到寄存器；STR指令用于将数据从寄存器存储到内存中。
三、算术运算指令算术运算指令是用于进行算术运算的指令。
常用的算术运算指令有ADD、SUB、MUL、DIV等。
ADD指令用于进行加法运算；SUB 指令用于进行减法运算；MUL指令用于进行乘法运算；DIV指令用于进行除法运算。
四、逻辑运算指令逻辑运算指令是用于进行逻辑运算的指令。
常用的逻辑运算指令有AND、OR、NOT等。
AND指令用于进行按位与运算；OR指令用于进行按位或运算；NOT指令用于进行按位取反运算。
五、条件分支指令条件分支指令用于根据条件进行跳转的指令。
常用的条件分支指令有CMP、BEQ、BNE等。
CMP指令用于比较两个操作数的大小；BEQ指令用于在两个操作数相等时跳转；BNE指令用于在两个操作数不相等时跳转。
六、循环指令循环指令用于实现循环结构的指令。
常用的循环指令有B、BL等。
B指令用于无条件跳转到指定地址；BL指令用于跳转到指定地址并保存返回地址。
七、函数调用指令函数调用指令用于调用函数的指令。
常用的函数调用指令有CALL、RET等。
CALL指令用于调用函数，并将返回地址保存到栈中；RET 指令用于从函数中返回，并将返回地址从栈中弹出。
八、堆栈指令堆栈指令用于操作堆栈的指令。
常用的堆栈指令有PUSH、POP等。
PUSH指令用于将数据压入栈中；POP指令用于从栈中弹出数据。
集合的并、交运算C语言
集合的并、交运算(C语言) 在C语言中，可以使用逻辑运算符和位运算符来实现集合的并、交运算。
首先，我们需要定义两个布尔类型的数组来表示两个集合。
假设我们有两个集合A和B，它们的元素都是0或1，其中0表示该位置不属于该集合，1表示该位置属于该集合。
我们可以使用以下代码来定义两个集合：int A[10] = {0, 1, 0, 0, 1, 1, 0, 1, 0, 0}; // 集合Aint B[10] = {0, 0, 1, 0, 1, 0, 1, 1, 0, 0}; // 集合B接下来，我们可以使用逻辑运算符来实现集合的并、交运算。
1.并运算并运算即将集合A和集合B的所有元素合并成一个新的集合。
我们可以使用逻辑运算符“|”来实现并运算，代码如下：int C[10]; // 新集合Cfor (int i = 0; i < 10; i++) {C[i] = A[i] | B[i]; // 并运算}在上面的代码中，我们使用循环遍历所有元素，对于每个元素，如果它属于集合A或集合B，则将它赋值给新集合C。
这里使用了逻辑运算符“|”，表示两个集合的并运算。
2.交运算交运算即找出集合A和集合B中共有的元素组成一个新的集合。
我们可以使用逻辑运算符“&”来实现交运算，代码如下：int D[10]; // 新集合Dfor (int i = 0; i < 10; i++) {D[i] = A[i] & B[i]; // 交运算}在上面的代码中，我们同样使用循环遍历所有元素，对于每个元素，如果它既属于集合A又属于集合B，则将它赋值给新集合D。
这里使用了逻辑运算符“&”，表示两个集合的交运算。
需要注意的是，在实际应用中，我们可能需要对数组进行动态分配内存，以适应不同大小的集合。
此外，我们还需要注意数组下标从0开始计数的问题。
集合的并、交和差运算的算法
<数据结构>课程设计题目:（1.1）集合的并、交和差运算的算法班级:姓名:XXX学号:完成日期:问题描述：设计一个能演示集合的并、交和差运算的程序。
要求：演示程序以用户和计算机的对话方式执行。
1、需求分析（1）输入的形式：命令：集合；如：Create:A;delete:A;Create:B{1,2,3,4,5};Show:BShow*;Help;Operation:A=B;Operation:A=A+B;输入值得范围：数值类型：int；最多创建集合数：100；（2）输出的形式：Error:Not find…Result:OK!Result:A={1,2,3,4,5};注意：集合中的元素是安从小到大的顺序排的，并且集合中的元素唯一。
（3）程序所能达到的功能。
实现集合的创建，增删改查，以及集合间的并、交和差运算。
（4）测试数据。
输入：Create:A={12,1,2,3,4};Create:B={3,4,5,6};Operation:C=A+B;Operation:D=A-B;Operation:E=A*B;Show*:;Quit:;2、概要设计图3.1 主题布局3、详细设计（1）基本操作：创建列表：State CreateList(List L)；删除列表中的元素:State DeleteList(List L,int index);向列表添加元素：State Add(List L,TYPE e)；查找元素：State FindByIndex(List L,int index,_TYPE e)；（2）集合操作：排序：void Sortascending(List L)；去重：State uniq_List(li l0,List L)删除集合：去除索引indexx.l[i];创建集合：void Create(char* name,char* str);查找集合：int find(const char* str,char ch,int start)；（3）集合间的操作：集合合并：State Union_List(li a,li b,List c)；集合交集：State Intersection_List(li a,li b,List c)；集合差集：State Substract_List(li a,li b,List c)；（4）数据结构typedef struct{TYPE* l;//整型数组int length;//列表长度int max_len;//列表最大长度}li,*List,**_List;li list_arr[100];//集合数组li indexx;//列表索引char str_arr[100][20];//字符串数组4、调试分析（无）5、用户使用说明集合格式:A={1,2,3};('A'为集合名称,'{}'为集合,'1'为集合中的元素) help:; --帮助create:A={1,2,3}; --创建集合Adelete:A; --删除集合Ashow:A; --显示集合Ashow*:; --显示所有集合cls:; --清屏operation:A=B+{1,2,3}*B-{1,5,6} --集合运算(无优先规则，即顺序运算) '+'为集合的并'-'为集合的差'*'为集合的交6、测试结果输出：Result:Create OK!Result: Create OK!Result: Create OK!Result: OK!Result: Create OK!Result: OK!Result: Create OK!Result: OK!Result:A={1,2,3,4,12}Result:B={3,4,5,6}Result:C={1,2,3,4,5,6,12}Result:D={1,2,5,6,12}Result:E={3,4}Result:exit...--------------------------------Process exited with return value 0Press any key to continue . . .图6.1:测试结果7、附录（附全部代码）/////////////////////////////////////////////////////////////////////////////// //编译环境：DEV-C++//日期：2014/12/6//名称：集合运算/////////////////////////////////////////////////////////////////////////////////// #include<stdio.h>#include<malloc.h>#include<string.h>#include<windows.h>#define MAX_LEN 20#define ADD_LEN 10#define OK 1#define TRUE 1//#define ERROR -1#define FALSE 0typedef int TYPE;typedef int State;typedef int BOOL;typedef TYPE* _TYPE;typedef struct{TYPE* l;int length;int max_len;}li,*List,**_List;State CreateList(List L){L->l=(_TYPE)malloc(MAX_LEN*sizeof(TYPE));if(!L->l)return ERROR;L->length=0;L->max_len=MAX_LEN;return OK;}State Add(List L,TYPE e){if(L->length>=L->max_len){_TYPE L0;L0=(_TYPE)realloc(L->l,(MAX_LEN+ADD_LEN)*sizeof(TYPE));if(!L0)return ERROR;L->l=L0;L->max_len+=ADD_LEN;}L->l[L->length]=e;++L->length;return OK;}State AddRange(List L,_TYPE e,int length){int i;if(length<0)return ERROR;_TYPE L0;L0=(_TYPE)realloc(L->l,(MAX_LEN+length)*sizeof(TYPE));if(!L0)return ERROR;L->l=L0;L->max_len+=length;for(i=0;i<length;++i){if(e[i])L->l[L->length+i]=e[i];else return ERROR;}L->length+=length;return OK;}State FindByIndex(List L,int index,_TYPE e){if(index<0||index>=L->length)return ERROR;*e=L->l[index];return OK;}int FindByE(List L,TYPE e){int i;for(i=0;i<L->length;++i){if(e==L->l[i])return i;}return -1;}void swap(_TYPE a,_TYPE b){TYPE t=*a;*a=*b;*b=t;}void Sort(List L,int campare(TYPE,TYPE)){int i,j;for(i=0;i<L->length-1;++i){for(j=i+1;j<L->length;++j){if(campare(L->l[i],L->l[j])){swap(&L->l[i],&L->l[j]);}}}}int IsMax(TYPE a,TYPE b){return a>b;}int IsMin(TYPE a,TYPE b){return a<b;}void SortDescending(List L){Sort(L,IsMin);}void Sortascending(List L){Sort(L,IsMax);}State DeleteList(List L,int index){int i,j;_TYPE L0;if(index<0||index>=L->length)return ERROR;if(L->length>=MAX_LEN&&L->length-1>L->max_len-ADD_LEN){ L0=(_TYPE)realloc(L->l,(MAX_LEN-ADD_LEN)*sizeof(TYPE));if(!L0)return ERROR;L->l=L0;L->max_len-=ADD_LEN;}for(i=L->length-2;i>=index;--i){L->l[i]=L->l[i+1];}--L->length;}State uniq_List(li l0,List L){int length=l0.max_len,i,j;BOOL k;L->l=(_TYPE)malloc(sizeof(TYPE)*length);if(!L->l)return ERROR;L->length=0;L->max_len=length;for(i=0;i<l0.length;++i){k=TRUE;for(j=i+1;j<l0.length;++j){if(l0.l[i]==l0.l[j]){k=FALSE;break;}}if(k){Add(L,l0.l[i]);}}return OK;}State Union_List(li a,li b,List c){_TYPE a0=a.l;_TYPE b0=b.l;int i,j;c->l=(_TYPE)malloc(sizeof(TYPE)*(a.length+b.length));if(!c->l)return ERROR;c->max_len=a.length+b.length;c->length=0;i=a.length;j=b.length;while(i&&j){if(*a0>*b0){Add(c,*b0);b0++;j--;}else{Add(c,*a0);a0++;i--;}}while(i){Add(c,*a0);a0++;i--;}while(j){Add(c,*b0);b0++;j--;}return OK;}State Intersection_List(li a,li b,List c){_TYPE a0=a.l;_TYPE b0=b.l;int i,j;c->l=(_TYPE)malloc(sizeof(TYPE)*(a.length+b.length));if(!c->l)return ERROR;c->max_len=a.length+b.length;c->length=0;i=a.length;j=b.length;while(i&&j){if(*a0>*b0){b0++;j--;}else if((*a0)==(*b0)){Add(c,*a0);b0++;a0++;i--;j--;}else{a0++;i--;}}return OK;}State Chu_List(li a,li b,List c){_TYPE a0=a.l;_TYPE b0=b.l;int i,j;c->l=(_TYPE)malloc(sizeof(TYPE)*(a.length+b.length));if(!c->l)return ERROR;c->max_len=a.length+b.length;c->length=0;i=a.length;j=b.length;while(i&&j){if(*a0>*b0){Add(c,*b0);b0++;j--;}else if((*a0)==(*b0)){b0++;a0++;i--;j--;}else{Add(c,*a0);a0++;i--;}}while(i){Add(c,*a0);a0++;i--;}while(j){Add(c,*b0);b0++;j--;}return OK;}State Substract_List(li a,li b,List c){_TYPE a0=a.l;_TYPE b0=b.l;int i,j;c->l=(_TYPE)malloc(sizeof(TYPE)*(a.length+b.length));if(!c->l)return ERROR;c->max_len=a.length+b.length;c->length=0;i=a.length;j=b.length;while(i&&j){if(*a0>*b0){Add(c,*b0);b0++;j--;}else if((*a0)==(*b0)){b0++;a0++;i--;j--;}else{Add(c,*a0);a0++;i--;}}while(i){Add(c,*a0);a0++;i--;}return OK;}/////////////////////////////////////////////////////////////////li list_arr[100];li indexx;char str_arr[100][20];///////////////////////////////////////////////////////////////void Printf(char* str,List L){int i;if(L->length<=0){if(strlen(str)>0){printf("%s={(None)}\n",str);}return;}printf("%s={",str);for(i=0;i<L->length-1;++i){printf("%d,",L->l[i]);}printf("%d}\n",L->l[L->length-1]);}int find(const char* str,char ch,int start){int i,length=strlen(str);for(i=start;i<length;++i){if(str[i]==ch)return i;}return -1;}void Str_cpy(const char* str,int start,int end,char *str0){ int i,length=strlen(str);if(start<0||start>=length||end<0||end>length||end<=start){ return;}for(i=start;i<end;i++){if(str[i]==' '){++start;}elsestr0[i-start]=str[i];}str0[i-start]='\0';}void Caps(char* str,BOOL Up){int length=strlen(str),i;if(Up){for(i=0;i<length;++i){if(str[i]>='a'&&str[i]<='z'){str[i]-=32;}}}else{for(i=0;i<length;++i){if(str[i]<='Z'&&str[i]>='A'){str[i]+=32;}}}}void Read(List L,char* str){li list;CreateList(&list);int i,num=0,length=strlen(str);if(length<=0)return;for(i=0;i<length;++i){if(str[i]==','){Add(&list,num);num=0;}else{num*=10;num+=(str[i]-'0');}}if(num>0){Add(&list,num);}Sortascending(&list);uniq_List(list,L);}void Create(char* name,char* str){li list;int length=strlen(str),i;if(findByName(name)>=0){printf("Error:%s have already exist!\n",name);return;}CreateList(&list);Read(&list,str);strcpy(str_arr[indexx.length],name);list_arr[indexx.length]=list;Add(&indexx,indexx.length);printf("Result:Create OK!\n");}int findByName(char* str){int i;for(i=0;i<indexx.length;++i){if(strcmp(str_arr[indexx.l[i]],str)==0){return i;}}return -1;}int findOperater(const char* str,int start){int i=0,length=strlen(str);for(i=start;i<length;++i){if(str[i]=='+'||str[i]=='-'||str[i]=='*'||str[i]=='/')return i;}return -1;}li operate(char* str,int start,li li_f){int i,length,end,index;li li_l,li_r;char set[100];end=findOperater(str,start+1);if(start<0){uniq_List(li_f,&li_r);return li_r;}if(str[start+1]=='{'){Str_cpy(str,find(str,'{',start+1)+1,find(str,'}',start+1),set);Read(&li_l,set);}else{if(end<0)end=find(str,';',0);for(i=start+1;i<end;i++){set[i-start-1]=str[i];}set[i-start-1]='\0';index=findByName(set);if(index<0){printf("Error:%s have not exist!",set);return li_r;}li_l=list_arr[index];}switch(str[start]){case '+':Union_List(li_f,li_l,&li_r); break;case '-':Substract_List(li_f,li_l,&li_r); break;case '*':Intersection_List(li_f,li_l,&li_r);break;case '/':Chu_List(li_f,li_l,&li_r);break;default:printf("Error:opareter error...\n");}if(end==find(str,';',0))end=-1;return operate(str,end,li_r);}void func(char* str){char command[20]={"\0"};char str0[100],name[20]={"\0"};int i,j,end,start=find(str,':',0);li li_f;Str_cpy(str,0,start,command);Caps(command,FALSE);if(strcmp(str,"show*;")==0)goto loop;else if(strcmp(str,"quit;")==0)goto loop2;else if(strcmp(str,"help;")==0)goto loop3;if(strcmp(command,"delete")==0){Str_cpy(str,start+1,find(str,';',start+1),name);start=findByName(name);if(start<0){printf("Error:Not find!\n");return;}DeleteList(&indexx,start);printf("Result:Delete OK!\n");}else if(strcmp(command,"create")==0){Str_cpy(str,start+1,find(str,'=',start+1),name);if(strlen(name)==0){Str_cpy(str,start+1,find(str,';',start+1),name);if(strlen(name)<=0)return;}elseStr_cpy(str,find(str,'{',start+1)+1,find(str,'}',start+1),str0);Create(name,str0);}else if(strcmp(command,"operation")==0){end=find(str,'=',start+1);Str_cpy(str,start+1,end,name);if(strlen(name)==0){return;}i=findByName(name);if(i<0){Create(name,"");i=findByName(name);}CreateList(&li_f);if(str[end+1]=='{'){Str_cpy(str,find(str,'{',start+1)+1,find(str,'}',start+1),name);Read(&li_f,name);end=findOperater(str,end+1);}else{name[0]='\0';start=end;end=findOperater(str,end+1);if(end<0)Str_cpy(str,start+1,strlen(str)-1,name);elseStr_cpy(str,start+1,end,name);start=findByName(name);if(start<0){printf("Error:'%s' have not exist!",name);return;}li_f=list_arr[start];}Str_cpy(str,end,strlen(str),str0);list_arr[i]=li_f;list_arr[i]=operate(str0,findOperater(str0,0),li_f);printf("Result:OK!\n");}else if(strcmp(command,"show")==0){Str_cpy(str,start+1,find(str,';',start+1),name);start=findByName(name);if(start<0){printf("Error:Not find %s!\n",name);return;}printf("Result:");Printf(str_arr[indexx.l[start]],&list_arr[indexx.l[start]]);}else if(strcmp(command,"show*")==0){loop: for(i=0;i<indexx.length;++i){printf("Result:");Printf(str_arr[indexx.l[i]],&list_arr[indexx.l[i]]);}}else if(strcmp(command,"quit")==0){loop2: printf("Result:exit...");exit(0);}else if(strcmp(command,"help")==0){loop3:printf("<==================================================>\ n\n");printf("集合格式:A={1,2,3};('A'为集合名称,'{}'为集合,'1'为集合中的元素)\n");printf("help:; --帮助\n");printf("create:A={1,2,3}; --创建集合A\n");printf("delete:A; --删除集合A\n");printf("show:A; --显示集合A\n");printf("show*:; --显示所有集合\n");printf("cls:; --清屏\n");printf("operation:A=B+{1,2,3}*B-{1,5,6} --集合运算(无优先规则，即顺序运算)\n\t'+'为集合的并\n\t'-'为集合的差\n\t'*'为集合的交\n\n");printf("<==================================================>\ n\n");}else{system(command);}}BOOL IsIlligle(const char* str){int i,length=strlen(str);BOOL k=TRUE;for(i=0;i<length;++i){if((str[i]>='0'&&str[i]<='9')||(str[i]>='A'&&str[1]<='Z')||(str[1]>='a'&&str[i]<='z') )continue;switch(str[i]){case ';':case ':':case '{':case '}':case '+':case '-':case '*':case '=':case ' ':case '/':continue;default:k=FALSE;}break;}return k;}int main(){char str[100],str1[100];CreateList(&indexx);printf("输入'help;'查询...\n");while(1){printf("List->");gets(str);Str_cpy(str,0,strlen(str),str1);if(IsIlligle(str1)){func(str1);}else{printf("Error:have illegal character!\n");}}return 0;}。
集合的并、交运算(C语言)
题目一：集合的并、交运算1设计思想首先，建立两个带头结点的有序单链表表示集合A和B。
须注意的是：利用尾插入法建立有序单链表，输入数值是升序排列。
其次，根据集合的运算规则，利用单链表的有序性，设计交、并和差运算。
根据集合的运算规则，集合A∩B中包含所有既属于集合A又属于集合B的元素。
因此，须查找单链表A和B中的相同元素并建立一个链表存于此链表中。
根据集合的运算规则，集合A∪B中包含所有或属于集合A或属于集合B的元素。
因此，遍历两链表的同时若元素相同时只将集合A中的元素存于链表中，若集合A中的下一个元素小于B中的元素就将A中的元素存于新建的链表中。
反之将B中的元素存于链表中。
2所用数据结构线性结构利用链式存储结构实现集合的基本运算。
3源代码分析#include<stdio.h>#include<stdlib.h>#define ERROR 0#define OK 1typedef int Status;typedef char Elemtype;typedef struct LNode{ 线性表的链式存储结构Elemtype data;struct LNode *next;}Lnode,*Linklist;#include"text.h"LNode* Greatlist(int *N,int n) //建立一个带有头结点的单链表{Linklist p,q,L;L=p=(LNode *)malloc(sizeof(LNode));L->next=NULL;if(n!=0){for(int i=0;i<n;i++){q=(LNode *)malloc(sizeof(LNode)); //尾部插入结点建立带有头结点单链表q->data=N[i];p->next=q; //指针后移p=q;}}p->next=NULL; //对于非空表，最后结点的指针域放空指针return L;}LNode* jiaoji(Linklist la,Linklist lb) //求两集合的交集{Linklist pa,pb,pc,Lc;pa=la->next;pb=lb->next;Lc=(Linklist)malloc(sizeof(LNode)); //申请存储空间Lc->next=NULL;pc=Lc;while(pa&&pb){if(pa->data==pb->data){pc->next=(Linklist)malloc(sizeof(LNode));//若相等就申请存储空间链到Lc上pc=pc->next;pc->data=pa->data;pa=pa->next; //la，lb的指针后移pb=pb->next;}else if(pa->data>pb->data)//若pa所指的元素大于pb所指的元素pb 指针后移{ pb=pb->next; }else{ pa=pa->next; }}pc->next=NULL;//最后给pc的next赋NULLreturn Lc;}LNode* bingji(Linklist la,Linklist lb) //求两集合的并集{Linklist pa,pb,pc,lc;pa=la->next;pb=lb->next;lc=(Linklist)malloc(sizeof(LNode));lc->next=NULL;pc=lc;while(pa&&pb){if(pa->data==pb->data){pc->next=(Linklist)malloc(sizeof(LNode));//若pa所指的元素等于pb所指的元素申请空间将值存入链表lc，pa，pb指针后移pc=pc->next;pc->data=pa->data;pa=pa->next;pb=pb->next;}else if(pa->data>pb->data){pc->next=(Linklist)malloc(sizeof(LNode));//若pa所指的元素大于pb所指的元素申请空间将值存入链表lc，pb指针后移pc=pc->next;pc->data=pb->data;pb=pb->next;}else{pc->next=(Linklist)malloc(sizeof(LNode));//若pa所指的元素小于pb所指的元素申请空间将值存入链表lc，pa指针后移pc=pc->next;pc->data=pa->data;pa=pa->next;}}pc->next=pa?pa:pb;return lc;}void Print_LinkList(Linklist L) //输出元素{Linklist p=L->next;while(p)//链表不为空时输出链表中的值{printf(" %3c" ,p->data);p=p->next;}printf(" \n" );}void main(){Linklist L1,L2,La,Lb;int A[4]={'a','b','c','f'};int B[4]={'c','d','e','f'};printf("1)含多个结点的顺序表[‘a’,’b’,’c’,’f’]和[‘c’,’d’,’e’,’f’]\n");printf("建立链表L1为\n");L1=Greatlist(A,4);Print_LinkList(L1);printf("建立链表L2为\n");L2=Greatlist(B,4);Print_LinkList(L2);printf("两链表的交集为：\n");La=jiaoji(L1,L2);Print_LinkList(La);printf("两链表的并集为：\n");Lb=bingji(L1,L2);Print_LinkList(Lb);printf("2)含一个结点的顺序表[‘a’]和空表[]\n");int A1[1]={'a'};int B1[1]={'0'};printf("建立链表L1为\n");L1=Greatlist(A1,1);Print_LinkList(L1);printf("建立链表L2为\n");L2=Greatlist(B1,0);Print_LinkList(L2);printf("两链表的交集为：\n");La=jiaoji(L1,L2);Print_LinkList(La);printf("两链表的并集为：\n");Lb=bingji(L1,L2);Print_LinkList(Lb);printf("3)2个空表\n");int A2[1]={'0'};int B2[1]={'0'};printf("建立链表L1为\n");L1=Greatlist(A2,0);Print_LinkList(L1);printf("建立链表L2为\n");L2=Greatlist(B2,0);Print_LinkList(L2);printf("两链表的交集为：\n");La=jiaoji(L1,L2);Print_LinkList(La);printf("两链表的并集为：\n");Lb=bingji(L1,L2);Print_LinkList(Lb);free(L1);free(L2);free(La);free(Lb);}4测试数据及运行结果(1)含多个结点的顺序表[‘a’,’b’,’c’,’f’]和[‘c’,’d’,’e’,’f’](2)含一个结点的顺序表[‘a’]和空表[] (3)2个空表5算法分析（1）LNode* Greatlist()//尾插法建立链表算法的时间复杂度为O（n），n为输入元素个数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
题目一：集合的并、交运算1设计思想首先，建立两个带头结点的有序单链表表示集合A和B。
须注意的是：利用尾插入法建立有序单链表，输入数值是升序排列。
其次，根据集合的运算规则，利用单链表的有序性，设计交、并和差运算。
根据集合的运算规则，集合A∩B中包含所有既属于集合A又属于集合B的元素。
因此，须查找单链表A和B中的相同元素并建立一个链表存于此链表中。
根据集合的运算规则，集合A∪B中包含所有或属于集合A或属于集合B的元素。
因此，遍历两链表的同时若元素相同时只将集合A中的元素存于链表中，若集合A中的下一个元素小于B中的元素就将A中的元素存于新建的链表中。
反之将B中的元素存于链表中。
2所用数据结构线性结构利用链式存储结构实现集合的基本运算。
3源代码分析#include<stdio.h>#include<stdlib.h>#define ERROR 0#define OK 1typedef int Status;typedef char Elemtype;typedef struct LNode{ 线性表的链式存储结构Elemtype data;struct LNode *next;}Lnode,*Linklist;#include"text.h"LNode* Greatlist(int *N,int n) //建立一个带有头结点的单链表{Linklist p,q,L;L=p=(LNode *)malloc(sizeof(LNode));L->next=NULL;if(n!=0){for(int i=0;i<n;i++){q=(LNode *)malloc(sizeof(LNode)); //尾部插入结点建立带有头结点单链表q->data=N[i];p->next=q; //指针后移p=q;}}p->next=NULL; //对于非空表，最后结点的指针域放空指针return L;}LNode* jiaoji(Linklist la,Linklist lb) //求两集合的交集{Linklist pa,pb,pc,Lc;pa=la->next;pb=lb->next;Lc=(Linklist)malloc(sizeof(LNode)); //申请存储空间Lc->next=NULL;pc=Lc;while(pa&&pb){if(pa->data==pb->data){pc->next=(Linklist)malloc(sizeof(LNode));//若相等就申请存储空间链到Lc上pc=pc->next;pc->data=pa->data;pa=pa->next; //la，lb的指针后移pb=pb->next;}else if(pa->data>pb->data)//若pa所指的元素大于pb所指的元素pb 指针后移{ pb=pb->next; }else{ pa=pa->next; }}pc->next=NULL;//最后给pc的next赋NULLreturn Lc;}LNode* bingji(Linklist la,Linklist lb) //求两集合的并集{Linklist pa,pb,pc,lc;pa=la->next;pb=lb->next;lc=(Linklist)malloc(sizeof(LNode));lc->next=NULL;pc=lc;while(pa&&pb){if(pa->data==pb->data){pc->next=(Linklist)malloc(sizeof(LNode));//若pa所指的元素等于pb所指的元素申请空间将值存入链表lc，pa，pb指针后移pc=pc->next;pc->data=pa->data;pa=pa->next;pb=pb->next;}else if(pa->data>pb->data){pc->next=(Linklist)malloc(sizeof(LNode));//若pa所指的元素大于pb所指的元素申请空间将值存入链表lc，pb指针后移pc=pc->next;pc->data=pb->data;pb=pb->next;}else{pc->next=(Linklist)malloc(sizeof(LNode));//若pa所指的元素小于pb所指的元素申请空间将值存入链表lc，pa指针后移pc=pc->next;pc->data=pa->data;pa=pa->next;}}pc->next=pa?pa:pb;return lc;}void Print_LinkList(Linklist L) //输出元素{Linklist p=L->next;while(p)//链表不为空时输出链表中的值{printf(" %3c" ,p->data);p=p->next;}printf(" \n" );}void main(){Linklist L1,L2,La,Lb;int A[4]={'a','b','c','f'};int B[4]={'c','d','e','f'};printf("1)含多个结点的顺序表[‘a’,’b’,’c’,’f’]和[‘c’,’d’,’e’,’f’]\n");printf("建立链表L1为\n");L1=Greatlist(A,4);Print_LinkList(L1);printf("建立链表L2为\n");L2=Greatlist(B,4);Print_LinkList(L2);printf("两链表的交集为：\n");La=jiaoji(L1,L2);Print_LinkList(La);printf("两链表的并集为：\n");Lb=bingji(L1,L2);Print_LinkList(Lb);printf("2)含一个结点的顺序表[‘a’]和空表[]\n"); int A1[1]={'a'};int B1[1]={'0'};printf("建立链表L1为\n");L1=Greatlist(A1,1);Print_LinkList(L1);printf("建立链表L2为\n");L2=Greatlist(B1,0);Print_LinkList(L2);printf("两链表的交集为：\n");La=jiaoji(L1,L2);Print_LinkList(La);printf("两链表的并集为：\n"); Lb=bingji(L1,L2);Print_LinkList(Lb);printf("3)2个空表\n");int A2[1]={'0'};int B2[1]={'0'};printf("建立链表L1为\n");L1=Greatlist(A2,0);Print_LinkList(L1);printf("建立链表L2为\n");L2=Greatlist(B2,0);Print_LinkList(L2);printf("两链表的交集为：\n"); La=jiaoji(L1,L2);Print_LinkList(La);printf("两链表的并集为：\n"); Lb=bingji(L1,L2);Print_LinkList(Lb);free(L1);free(L2);free(La);free(Lb);}4测试数据及运行结果(1)含多个结点的顺序表[‘a’,’b’,’c’,’f’]和[‘c’,’d’,’e’,’f’](2)含一个结点的顺序表[‘a’]和空表[] (3)2个空表5算法分析（1）LNode* Greatlist()//尾插法建立链表算法的时间复杂度为O（n），n为输入元素个数。
（2）LNode* jiaoji(Linklist la,Linklist lb)算法时间复杂度为O（m+n），m为集合A元素个数，n为集合B元素个数。
（3）LNode* bingji(Linklist la,Linklist lb)算法时间复杂度为O（m+n），m为集合A元素个数，n为集合B元素个数。
（4）void Print_LinkList(Linklist L)算法时间复杂度为O（n）n为集合元素个数。