第二次离散实验报告.docx
《第二次离散实验报告.docx》由会员分享，可在线阅读，更多相关《第二次离散实验报告.docx（37页珍藏版）》请在冰豆网上搜索。
第二次离散实验报告
“离散数学”实验报告
（实验1）
专业网络工程
班级网133
学号139074337
姓名李阳
一.实验目的；
本实验课程是计算机专业学生的一门专业基础课程，通过实验，帮助学生更好地掌握计算机科学技术常用的离散数学中的概念、性质和运算；通过实验提高学生编写实验报告、总结实验结果的能力；使学生具备程序设计的思想，能够独立完成简单的算法设计和分析。
熟悉掌握集合中的交、并、相对补、对称差、笛卡尔乘积、以及集合间的关系运算等，进一步能用它们来解决实际问题。
二.实验内容；
从键盘输入两个集合A和B的元素，
求它们的交∩、并∪、相对补-、对称差（+）、笛卡尔乘积×、以及集合间的关系复合运算×
三.实验原理；
1.实验原理
（1）交：
A∩B={x|x∈A∧x∈B}
对于集合A和集合B，由即属于A又属于B的所有元素所组成的集合，。
（2）并：
A∪B={x|x∈A∨x∈B}
若A和B是集合，则A和B并集是有所有A的元素或所有B的元素，而没有其他元素的集合。
（3）相对补：
B-A={x|x∈B，x∉A}
A-B={x|x∈A，x∉B}
若A和B是集合，则A在B中的相对补集，或叫做B和A的集合论差，是这样一个集合，其元素属于B，但不属于A。
（4）对称差：
A（+）B={x|x∈A∪B,x∉A∩B}
A（+）B=（A∪B）—（A∩B）
A（+）B=（A—B）∪（B—A）
集合A与集合B中所有不属于A∩B的元素的集合。
（5）笛卡尔乘积：
AxB={|x∈A∧y∈B}
设A,B为集合，用A中元素为第一元素，B中元素为第二元素构成有序对，所有这样的有序对组成的集合叫做A与B的笛卡尔积，记作AxB.
（6）求集合间关系的复合运算:
RoS=
设R是X到Y的关系，S是Y到Z的关系，则RoS称为R和S的复合关系。
四.实验数据及结果分析；
欢迎界面：
程序运行界面一：
输入两个简单一点的集合：
程序运行界面二：
输入两个元素为序偶的集合：
五．源程序清单；
//本次最困难的地方是逻辑理不清，导致程序无错，但是输不出来想要的。
#include"stdio.h"
#include"string.h"
#include"stdlib.h"
constunsignedintNUMBER=10;
constunsignedintLONG=15;
constunsignedintHALF_LONG=8;
//f=';'=59Fen[]="；"Fen[0]=-93Fen[1]=-69
constintE_Fen=59,C_Fen1=-93,C_Fen2=-69;
//d=','=44Dou[]="，"Dou[0]=-93Dou[1]=-84
constintE_Dou=44,C_Dou1=-93,C_Dou2=-84;
//E_L_Kuo='<'=60E_R_Kuo='>'=62
constintE_L_Kuo=60,E_R_Kuo=62;
//C_L_Kuo[]="《"
constintC_L_Kuo1=-95,C_L_Kuo2=-74;
//C_R_Kuo[]="》"
constintC_R_Kuo1=-95,C_R_Kuo2=-73;
unsignedintstringcmp（constchar*p1,constchar*p2）;
voidwelcome（）;
voidget_s（char**p,charg）;
charchoice（）;
voidjiao（char**pa,char**pb,char**p_ab）;
voidbing（char**pa_to_pb,char**pb_to_pa,char**p_ab）;
voidx_d_b（char**p,char**p_ab,char**p_to）;
voidd_c_c（char**pa_to_pb,char**pb_to_pa）;
voidprint（char**p）;
voidfree_all（char**p）;
voidnew_Fu_He（char**pa,char**pb,char**pc）;
voidnew_Xuou_Fu_He（char**pa,char**pb,char**pc）;
unsignedintjie_qu（constchar*x1,constchar*x2,char*f_jq,char*s_jq）;
voidDele_Same_Str（char**pc）;
unsignedintstringcmp（constchar*p1,constchar*p2）
{
inti1,i2;
for（i1=0,i2=0;p1[i1]!
='\0';i1++,i2++）
{
if（p1[i1]==p2[i2]）
continue;
//E_Dou=44,C_Dou1=-93,C_Dou2=-84
if（p1[i1]==C_Dou1&&p1[i1+1]==C_Dou2）
{
if（p2[i2]==E_Dou）
{
i1++;
continue;
}
}
if（p2[i2]==C_Dou1&&p2[i2+1]==C_Dou2）
{
if（p1[i1]==E_Dou）
{
i2++;
continue;
}
}
//E_L_Kuo=60C_L_Kuo1=-95,C_L_Kuo2=-74;
if（p1[i1]==C_L_Kuo1&&p1[i1+1]==C_L_Kuo2）
{
if（p2[i2]==E_L_Kuo）
{
i1++;
continue;
}
}
if（p2[i2]==C_L_Kuo1&&p2[i2+1]==C_L_Kuo2）
{
if（p1[i1]==E_L_Kuo）
{
i2++;
continue;
}
}
//E_R_Kuo=62C_R_Kuo1=-95,C_R_Kuo2=-73;
if（p1[i1]==C_R_Kuo1&&p1[i1+1]==C_R_Kuo2）
{
if（p2[i2]==E_R_Kuo）
{
i1++;
continue;
}
}
if（p2[i2]==C_R_Kuo1&&p2[i2+1]==C_R_Kuo2）
{
if（p1[i1]==E_R_Kuo）
{
i2++;
continue;
}
}
return1;
}
return0;
}
voidwelcome（）
{
printf（"************************************************************\n"）;
printf（"****\n"）;
printf（"****\n"）;
printf（"**欢迎进入逻辑运算软件**\n"）;
printf（"****\n"）;
printf（"**（可运算集合的交，并，相对补，对称差）**\n"）;
printf（"****\n"）;
printf（"****\n"）;
printf（"****\n"）;
printf（"**用∩表示交**\n"）;
printf（"**用∪表示并**\n"）;
printf（"**用-表示相对补**\n"）;
printf（"**用（+）表示对称差**\n"）;
printf（"**用表示集合为空**\n"）;
printf（"****\n"）;
printf（"**一次只能运算两个集合**\n"）;
printf（"**集合元素不得多于10个**\n"）;
printf（"**元素长度不得多于15个字节**\n"）;
printf（"****\n"）;
printf（"**每个元素间用分号；或者是;隔开**\n"）;
printf（"**eg:
…2；3…或者…2;3…**\n"）;
printf（"****\n"）;
printf（"**序偶自身之间用，或是,分开**\n"）;
printf（"**eg：
…《1,2》；《2，3》…**\n"）;
printf（"************************************************************\n\n"）;
}
voidget_s（char**p,charg）
{
char*s=NULL;
chart[LONG]={'\0'};
ints_i,p_k,t_j,t_m;
if（（s=（char*）calloc（LONG*NUMBER,sizeof（char）））==NULL）
{
printf（"内存分配失败！
\n"）;
exit
（1）;
}
printf（"请输入%c集合元素：
\n%c={",g,g）;
gets（s）;
putchar（'}'）;
putchar（'\n'）;
s_i=strlen（s）;
s[s_i]=';';
p_k=0;
//E_Fen=59,C_Fen1=-93,C_Fen2=-69
for（s_i=0,t_j=0;s[s_i]!
='\0';s_i++,t_j++）
{
if（s[s_i]!
=E_Fen）
{
if（s[s_i]!
=C_Fen1&&s[s_i]!
=C_Fen2）
t[t_j]=s[s_i];
//切记条件多时，就用if一个个表示出来，不可妄想省if，那样只会把逻辑搞的很混乱
if（s[s_i]==C_Fen1&&s[s_i+1]!
=C_Fen2）
t[t_j]=s[s_i];
}
if（（s[s_i]==E_Fen）||（s[s_i]==C_Fen2&&s[s_i-1]==C_Fen1））
{
if（（p[p_k]=（char*）calloc（LONG,sizeof（char）））==NULL）
{
printf（"内存分配失败！
\n"）;
exit
（1）;
}
strcpy（p[p_k],t）;
t_j=-1;
p_k++;
for（t_m=0;t_mt[t_m]='\0';
}
if（p_k>NUMBER）
{
printf（"集合元素多于%ud！
存储失败。
",NUMBER）;
exit
（1）;
}
}
free（s）;
}
charchoice（）
{
charc,s;
printf（"请输入选项：
\n"）;
while（!
（scanf（"%[0-6]c",&c）））
{
while（（s=getchar（））!
='\n'&&s!
=EOF）;
printf（"输入有误！
请重新输入。
\n"）;
}
returnc;
}
voidjiao（char**pa,char**pb,char**p_ab）
{
inta,b,a_b;
a_b=0;
for（a=0;pa[a]!
=NULL;a++）
for（b=0;pb[b]!
=NULL;b++）
if（!
（stringcmp（pa[a],pb[b]）））
{
p_ab[a_b]=pa[a];
a_b++;
}
}
voidx_d_b（char**p,char**p_ab,char**p_to）
{
//这个里面逻辑太混乱。
inti_p,j_ab,k_to;
intm;
m=0;
k_to=0;
for（i_p=0;p[i_p]!
=NULL;i_p++）
{
for（j_ab=0;p_ab[j_ab]!
=NULL;j_ab++）
if（!
stringcmp（p[i_p],p_ab[j_ab]））
{
m++;
break;
}
if（m==0）
{
p_to[k_to]=p[i_p];
k_to++;
}
m=0;
}
}
voidbing（char**pa_to_pb,char**pb_to_pa,char**p_ab）
{
printf（"A∪B={"）;
print（pa_to_pb）;
printf（";"）;
print（pb_to_pa）;
printf（";"）;
print（p_ab）;
printf（"}\n"）;
}
voidd_c_c（char**pa_to_pb,char**pb_to_pa）
{
printf（"A（+）B={"）;
print（pa_to_pb）;
printf（";"）;
print（pb_to_pa）;
printf（"}\n"）;
}
voidprint（char**p）
{
inti;
for（i=0;p[i+1]!
=NULL;i++）
printf（"%s;",p[i]）;
printf（"%s",p[i]）;
}
voidfree_all（char**p）
{
inti;
for（i=0;p[i]!
=NULL;i++）
free（p[i]）;
}
voidmain（）
{
char*A[NUMBER]={NULL},*B[NUMBER]={NULL},*A_and_B[NUMBER]={NULL};
char*A_B[NUMBER]={NULL},*B_A[NUMBER]={NULL};
char*new_FH[NUMBER*NUMBER]={NULL},*new_Xuou_FH[NUMBER*NUMBER]={NULL};
charc;
intn=0;
welcome（）;
get_s（A,'A'）;
get_s（B,'B'）;
jiao（A,B,A_and_B）;
x_d_b（A,A_and_B,A_B）;
x_d_b（B,A_and_B,B_A）;
printf（"*******************************************\n"）;
printf（"1:
A∩B\n"）;
printf（"2:
A∪B\n"）;
printf（"3:
A-B\n"）;
printf（"4:
B-A\n"）;
printf（"5:
A（+）B\n"）;
printf（"6:
A×B\n"）;
printf（"0:
Exit!
\n"）;
printf（"*******************************************\n"）;
while
（1）
{
c=choice（）;
if（c!
='0'）
{
n++;
if（n==1）
{
printf（"A={"）;
print（A）;
printf（"}\n"）;
printf（"B={"）;
print（B）;
printf（"}\n"）;
}
}
if（c=='0'）
break;
elseif（c=='1'）
{
printf（"A∩B={"）;
print（A_and_B）;
printf（"}\n"）;
}
elseif（c=='2'）
bing（A_B,B_A,A_and_B）;
elseif（c=='3'）
{
printf（"A-B={"）;
print（A_B）;
printf（"}\n"）;
}
elseif（c=='4'）
{
printf（"B-A={"）;
print（B_A）;
printf（"}\n"）;
}
elseif（c=='5'）
d_c_c（A_B,B_A）;
elseif（c=='6'）
{
printf（"A×B={"）;
//在这里判断可能会有些失误，实在是不想写了
if（（A[0][0]==E_L_Kuo）||（A[0][0]==C_L_Kuo1））
{
if（（B[0][0]==E_L_Kuo）||（B[0][0]==C_L_Kuo1））
{
new_Xuou_Fu_He（A,B,new_Xuou_FH）;
print（new_Xuou_FH）;
free_all（new_Xuou_FH）;
}
}
else
{
new_Fu_He（A,B,new_FH）;
print（new_FH）;
free_all（new_FH）;
}
printf（"}\n"）;
}
printf（"*******************************************\n"）;
}
free_all（A）;
free_all（B）;
}
//*************************************************
//在这部分是元素不是序偶的集合的复合代码：
voidnew_Fu_He（char**pa,char**pb,char**pc）
{
charfirst[HALF_LONG]={'\0'},second[HALF_LONG]={'\0'};
intia,ib,ic;
intj;
first[0]=E_L_Kuo;
second[0]=E_Dou;
ic=0;
for（ia=0;pa[ia]!
=NULL;ia++）
{
for（ib=0;pb[ib]!
=NULL;ib++）
{
strcat（first,pa[ia]）;
strcat（second,pb[ib]）;
for（j=1;second[j]!
='\0';j++）;
second[j]=E_R_Kuo;
if（（pc[ic]=（char*）calloc（LONG,sizeof（char）））==NULL）
{
printf（"内存分配失败！
\n"）;
exit
（1）;
}
strcpy（pc[ic],first）;
strcat（pc[ic],second）;
ic++;
for（j=1;j{
first[j]='\0';
second[j]='\0';
}
}
}
Dele_Same_Str（pc）;
}
//下面是元素是序偶的话进行复合处理的代码：
voidnew_Xuou_Fu_He（char**pa,char**pb,char**pc）
{
//f_jq是用于截取一个序偶的前半部分,s_jq是截取另一个序偶的后半部分
charf_jq[HALF_LONG]={'\0'},s_jq[HALF_LONG]={'\0'};
chard[]=",";
intia,ib,ic;
intj;
unsignedintk;
ic=0;
for（ia=0;pa[ia]!
=NULL;ia++）
for（ib=0;pb[ib]!
=NULL;ib++）
{
k=jie_qu（pb[ib],pa[ia],f_jq,s_jq）;//小心前面两个参数别传错了
if（k）
{
printf（"}\n"）;
printf（"序偶输入有误！
\n"）;
return;
}
if（（f_jq[0]=='\0'）||（s_jq[0]=='\0'））
{
printf（"}\n"）;
printf（"序偶输入有误！
\n"）;
return;
}
k=stringcmp（f_jq,s_jq）;
for（j=0;j{
f_jq[j]='\0';
s_jq[j]='\0';
}
if（k）
continue;
k=jie_qu（pa[ia],pb[ib],f_jq,s_jq）;//注意这个传参数的顺序.
if（（pc[ic]=（char*）calloc（LONG,sizeof（char）））==NULL）
{
printf（"内存分配失败！
\n"）;
exit
（1）;
}
for（j=HALF_LONG-2;j>0;j--）
f_jq[j]=f_jq[j-1];
f_jq[j]=E_L_Kuo;
for（j=0;s_jq[j]!
='\0';j++）;
s_jq[j]=E_R_Kuo;
strcpy（pc[ic],f_jq）;
strcat（pc[ic],d）;
strcat（pc[ic],s_jq）;
ic++;
for（j=0;j{
f_jq[j]='\0';
s_jq[j]='\0';
}
}
Dele_Same_Str（pc）;
}
unsignedintjie_qu（constchar*x1,constchar*x2,char*f_jq,char*s_jq）
{
inti,k;
//x1序偶前半部分给f_jq
i=0;
if（x1[0]!
=E_L_Kuo）
{
if（x1[0]!
=C_L_Kuo1）
return1;
}
if（x1[0]==E_L_Kuo）
i=1;
if（x1[0]==C_L_Kuo1）
升级会员 