离散第三次实验闭包.docx
《离散第三次实验闭包.docx》由会员分享，可在线阅读，更多相关《离散第三次实验闭包.docx（23页珍藏版）》请在冰豆网上搜索。
离散第三次实验闭包
一.实验目的；
本实验课程是计算机专业学生的一门专业基础课程，通过实验，帮助学生更好地掌握计算机科学技术常用的离散数学中的概念、性质和运算；通过实验提高学生编写实验报告、总结实验结果的能力；使学生具备程序设计的思想，能够独立完成简单的算法设计和分析。
熟悉掌握
二.实验内容；
三.实验原理；
1.实验原理
四.实验数据及结果分析；
欢迎界面：
程序运行界面一：
程序运行界面二：
五．源程序清单；
#include"stdio.h"
#include"string.h"
#include"stdlib.h"
constunsignedintNUMBER=15;
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）;
unsignedintjie_qu（constchar*x1,constchar*x2,char*f_jq,char*s_jq）;
voidRsame（char**R,char**R_S）;
charchoice（）;
voidprint（char**p）;
voidfree_all（char**p）;
voidI（char**x,char**I_x）;
voidRc（char**R,char**Rc）;
voidnew_Xuou_Fu_He（char**pa,char**pb,char**pc）;
voidDele_Same_Str（char**pc）;
unsignedintstringcmp（constchar*p1,constchar*p2）
{
//如果不同，那么就返回1，如果相同就返回0
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（）
{
//在这里说明集合X元素不得多余10个，二元关系R能的序偶不得多余15
printf（"************************************************************\n"）;
printf（"****\n"）;
printf（"****\n"）;
printf（"**欢迎进入逻辑运算软件**\n"）;
printf（"****\n"）;
printf（"**（可进行关系的闭包运算。
）**\n"）;
printf（"**（包括：
自反闭包r（R），对称闭包s（R），可传递闭包t（R））**\n"）;
printf（"****\n"）;
printf（"****\n"）;
printf（"**用∪表示并**\n"）;
printf（"**用表示集合为空**\n"）;
printf（"****\n"）;
printf（"**集合X元素不得多于10个**\n"）;
printf（"**集合X的二元关系R元素不得多于15个**\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）;
}
if（g=='X'）
printf（"请输入集合%c元素：
\n%c={",g,g）;
if（g=='R'）
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）
//总感觉这里对于这个空间的分配要把X与R进行区分开。
{
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）;
}
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）
i=2;
k=0;
//如果出现<,1>或是《，1》就会导致截取数组为空，
//不过没关系在Bi_Bao函数中有如果为空报警并结束函数.
while
（1）
{
if（（x1[i]==E_Dou）||（x1[i]==C_Dou1））
break;
f_jq[k]=x1[i];
k++;
i++;
}
//x2序偶后半部分给s_jq
for（i=0;;i++）
if（（x2[i]==E_Dou）||（x2[i]==C_Dou2））
break;
i=i+1;
k=0;
while
（1）
{
if（x2[i]==E_R_Kuo）
break;
if（x2[i]==C_R_Kuo1）
break;
s_jq[k]=x2[i];
k++;
i++;
}
return0;
}
voidRsame（char**R,char**R_S）
{
charf_jq[LONG]={'\0'},s_jq[LONG]={'\0'};
inti_R,i_RS,j,k;
i_RS=0;
for（i_R=0;R[i_R]!
=NULL;i_R++）
{
k=jie_qu（R[i_R],R[i_R],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;
if（（R_S[i_RS]=（char*）calloc（LONG,sizeof（char）））==NULL）
{
printf（"内存分配失败！
\n"）;
exit
（1）;
}
strcpy（R_S[i_RS],R[i_R]）;
i_RS++;
free（R[i_R]）;
for（j=i_R;R[j]!
=NULL;j++）
R[j]=R[j+1];
i_R=i_R-1;
}
}
charchoice（）
{
charc,s;
printf（"请输入选项：
\n"）;
while（!
（scanf（"%[0-3]c",&c）））
{
while（（s=getchar（））!
='\n'&&s!
=EOF）;
printf（"输入有误！
请重新输入。
\n"）;
}
returnc;
}
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*X[NUMBER]={NULL},*R[NUMBER]={NULL},*R_Same[NUMBER]={NULL};
char*I_x[NUMBER]={NULL},*R_c[NUMBER]={NULL};
char*t_R[NUMBER*7]={NULL};
char*R_R_1[NUMBER*2]={NULL},*R_R_2[NUMBER*3]={NULL};
charc;
inti,t_r,n;
t_r=0;
n=0;
welcome（）;
get_s（X,'X'）;
get_s（R,'R'）;
Rsame（R,R_Same）;
I（X,I_x）;
Rc（R,R_c）;
new_Xuou_Fu_He（R,R,R_R_1）;
new_Xuou_Fu_He（R_R_1,R,R_R_2）;
for（i=0;R_Same[i]!
=NULL;i++）
{
t_R[t_r]=R_Same[i];
t_r++;
}
for（i=0;R[i]!
=NULL;i++）
{
t_R[t_r]=R[i];
t_r++;
}
for（i=0;R_R_1[i]!
=NULL;i++）
{
t_R[t_r]=R_R_1[i];
t_r++;
}
for（i=0;R_R_2[i]!
=NULL;i++）
{
t_R[t_r]=R_R_2[i];
t_r++;
}
Dele_Same_Str（t_R）;
printf（"*******************************************\n"）;
printf（"1:
自反闭包r（R）=R∪I（x）\n"）;
printf（"2:
对称闭包S（R）=R∪R（c）\n"）;
printf（"3:
可传递闭包t（R）=R∪R^2∪R^3∪…\n"）;
printf（"0:
Exit!
\n"）;
printf（"*******************************************\n"）;
while
（1）
{
c=choice（）;
if（c!
='0'）
{
n++;
if（n==1）
{
printf（"X={"）;
print（X）;
printf（"}\n"）;
printf（"R={"）;
print（R_Same）;
printf（";"）;
print（R）;
printf（"}\n"）;
}
}
if（c=='0'）
break;
elseif（c=='1'）
{
printf（"r（R）={"）;
print（I_x）;
printf（";"）;
print（R）;
printf（"}\n"）;
}
elseif（c=='2'）
{
printf（"S（R）={"）;
print（R_Same）;
printf（";"）;
print（R）;
printf（";"）;
print（R_c）;
printf（"}\n"）;
}
elseif（c=='3'）
{
printf（"t（R）={"）;
print（t_R）;
printf（"}\n"）;
}
printf（"*******************************************\n"）;
}
free_all（t_R）;
free_all（I_x）;
free_all（R_c）;
}
voidI（char**x,char**I_x）
{
char*s=NULL;
chard[]=",";
charR_Kuo_Hao[]=">";
inti,j;
j=0;
for（i=0;x[i]!
=NULL;i++）
{
if（（s=（char*）calloc（LONG,sizeof（char）））==NULL）
{
printf（"内存分配失败！
\n"）;
exit
（1）;
}
s[0]=E_L_Kuo;
strcat（s,x[i]）;
strcat（s,d）;
strcat（s,x[i]）;
strcat（s,R_Kuo_Hao）;
I_x[j]=s;
j++;
s=NULL;
}
}
voidRc（char**R,char**Rc）
{
charf_jq[LONG]={'\0'},s_jq[LONG]={'\0'};
char*s=NULL;
chard[]=",";
charR_Kuo_Hao[]=">";
inti_R,i_Rc,j,k;
i_Rc=0;
for（i_R=0;R[i_R]!
=NULL;i_R++）
{
k=jie_qu（R[i_R],R[i_R],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;
}
if（（s=（char*）calloc（LONG,sizeof（char）））==NULL）
{
printf（"内存分配失败！
\n"）;
exit
（1）;
}
s[0]=E_L_Kuo;
strcat（s,s_jq）;
strcat（s,d）;
strcat（s,f_jq）;
strcat（s,R_Kuo_Hao）;
Rc[i_Rc]=s;
i_Rc++;
s=NULL;
for（j=0;j{
f_jq[j]='\0';
s_jq[j]='\0';
}
}
}
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）;
}
voidDele_Same_Str（char**pc）
{
inti,j,k,m;
char*p;
for（i=0;pc[i]!
=NULL;i++）
for（j=i+1;pc[j]!
=NULL;j++）
{
m=stringcmp（pc[i],pc[j]）;
if（m）
continue;
p=pc[j];
free（p）;
for（k=j;pc[k]!
=NULL;k++）
升级会员 