《离散数学》实验课程指导书.docx
《《离散数学》实验课程指导书.docx》由会员分享,可在线阅读,更多相关《《离散数学》实验课程指导书.docx(67页珍藏版)》请在冰豆网上搜索。
《离散数学》实验课程指导书
《离散数学》实验课程
指
导
书
计算机学院
1查找与排序
2集合与序列
3关系与函数
4图论
5网络模型
实验项目1查找与排序
一、实验目的
(1)掌握查找的问题描述,实现线性查找算法及二分查找算法;
(2)熟悉排序的问题描述,实现插入排序算法。
二、实验内容
1、线性查找(顺序)算法
顺序查找:
也称为线性查找,是最基本的查找技术。
查找过程是:
从表中第一个(或最后一个)记录开始,逐个进行记录的关键字和给定值进行比较,若某个记录的关键字和给定值相等,则查找成功;如果直到最后一个(或第一个)记录,其关键字和给定值比较都不等时,则表中没有所查的记录,查找失败。
#include
voidmain()
{
inta[101];//定义数组a,设置其长度为101
inti,n,num;
printf("**************************************************\n");
printf("顺序查找算法\n");
printf("**************************************************\n\n");
printf("您要在多少个数中进行线性查找,请输入(1~100):
");
scanf("%d",&n);
printf("\n");
while(n<1||n>100)//如果输入的数据列表长度不在[1,100]之间
printf("您输入的数不正确!
请重新输入。
\n");
}
printf("请您输入第1个整数a[1]:
scanf("%d",&a[1]);
i=2;
while(i<=n)
printf("请您输入第%d个整数a[%d]:
",i,i);
scanf("%d",&a[i]);
i++;
printf("\n输出数据列表:
for(i=1;i<=n;i++)
printf("%6d",a[i]);
printf("\n\n");
do
printf("请输入要查找的数:
scanf("%d",&num);
i=1;
while(a[i]!
=num&&i<=n)//在数据列表内搜索num
{i++;}
if(i==n+1)
printf("该表中没有您要查找的数据!
else
printf("您要查找的数是%d,在数据列表中的位序为%d。
\n",num,i);
}while(num!
=9999);//若输入的待查找的数不是999,则可持续搜索。
2、二分查找算法
折半查找(BinarySearch):
也称为二分查找。
它的前提是:
1)、线性表中的记录必须是关键字有序(通常是从小到大有序);2)、线性表必须采用顺序存储。
折半查找的基本思想是:
在有序表中,取中间记录作为比较对象,若给定值与中间记录的关键字相等,则查找成功;若给定值小于中间记录的关键字,则在中间记录的左半区继续查找;若给定值大于中间记录的关键字,则在中间记录的右半区继续查找。
不断反复,直到查找成功;或者直到最后都没有找到,查找失败。
mid计算公式:
mid=(low+high)/2=low+(high-low)/2;
inta[101];
intTop,Bottom,Mid;
intflag=1;//如果在列表中找到数字,则值为1,否则为0
intloc=-1;//要查找的数在列表中的位置,如果loca=-1表示列表中没有这个数;如果有这个数,则它的值为所在的位置
printf("折半查找算法\n");
printf("您要在多少个数中进行折半查找,请输入(1~100):
while(i<=n)//输入从小到大的表列
if(a[i]>a[i-1])
printf("您输入的数不满足升序要求,请重新输入!
\n");}
flag=1;//假设输入的数在列表中
Top=n;
Bottom=1;
Mid=(Top+Bottom)/2;
while(flag)
printf("Bottom=%2d,Top=%2d,Mid=%2d,a[%2d]=%2d\n",Bottom,Top,Mid,Mid,a[Mid]);
if((num>a[Top])||(numa[Top]或者num{loc=-1;flag=0;}elseif(a[Mid]==num)//如果num等于找到的数{loc=Mid;printf("找到数%d的位置%2d\n\n",num,loc);break;}elseif(a[Mid]>num)//若a[Mid]>num,则num一定在a[Bottom]和a[Mid-1]范围之内{Top=Mid-1;Mid=(Top+Bottom)/2;}elseif(a[Mid]{Bottom=Mid+1;Mid=(Top+Bottom)/2;}}if(loc==-1){printf("%d这个数在列表中没有找到。\n\n",num);}}while(num!=9999);//若输入的待查找的数不是999,则可持续搜索。}3、插入排序算法直接插入排序是一种插入排序。前提:数组元素a[0]用作哨兵或临时变量,a[1]~a[n]存放n个待排序的元素。基本思想是:从a[2]开始,将元素插入到前面已经排好序的有序表中,从而得到一个新的、记录数增加1的有序表。#includevoidmain(){inta[101];inti,j,k,l,m;printf("****************************************\n");printf("插入排序算法\n");printf("****************************************\n\n");printf("请输入数据列表长度:\n");scanf("%d",&l);printf("\n请输入%d个数字:\n",l);for(i=0;iscanf("%d",&a[i]);for(i=1;i{k=a[i];j=i-1;while((j>=0)&&(a[j]>k)){a[j+1]=a[j];j--;}a[j+1]=k;printf("\n第%d次插入排序后全部数据为:\n",i);for(m=0;m{printf("%d",a[m]);}}printf("\n\n按照插入排序法,你输入的数据由小到大排序为:\n");for(i=0;i{printf("%d",a[i]);}printf("\n");}4、冒泡排序算法#includevoidmain(){inta[101];inti,j,k,l,m;intexchanged;printf("****************************************\n");printf("冒泡排序算法\n");printf("****************************************\n\n");printf("请输入数据列表长度:\n");scanf("%d",&l);printf("\n请输入%d个数字:\n",l);for(i=0;iscanf("%d",&a[i]);i=0;do{exchanged=0;for(j=0;jif(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;exchanged=1;}if(i==0)printf("\n");printf("第%d趟冒泡排序法由小到大排序后:\n",i+1);for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
loc=-1;
flag=0;
elseif(a[Mid]==num)//如果num等于找到的数
loc=Mid;
printf("找到数%d的位置%2d\n\n",num,loc);
break;
elseif(a[Mid]>num)//若a[Mid]>num,则num一定在a[Bottom]和a[Mid-1]范围之内
Top=Mid-1;
elseif(a[Mid]{Bottom=Mid+1;Mid=(Top+Bottom)/2;}}if(loc==-1){printf("%d这个数在列表中没有找到。\n\n",num);}}while(num!=9999);//若输入的待查找的数不是999,则可持续搜索。}3、插入排序算法直接插入排序是一种插入排序。前提:数组元素a[0]用作哨兵或临时变量,a[1]~a[n]存放n个待排序的元素。基本思想是:从a[2]开始,将元素插入到前面已经排好序的有序表中,从而得到一个新的、记录数增加1的有序表。#includevoidmain(){inta[101];inti,j,k,l,m;printf("****************************************\n");printf("插入排序算法\n");printf("****************************************\n\n");printf("请输入数据列表长度:\n");scanf("%d",&l);printf("\n请输入%d个数字:\n",l);for(i=0;iscanf("%d",&a[i]);for(i=1;i{k=a[i];j=i-1;while((j>=0)&&(a[j]>k)){a[j+1]=a[j];j--;}a[j+1]=k;printf("\n第%d次插入排序后全部数据为:\n",i);for(m=0;m{printf("%d",a[m]);}}printf("\n\n按照插入排序法,你输入的数据由小到大排序为:\n");for(i=0;i{printf("%d",a[i]);}printf("\n");}4、冒泡排序算法#includevoidmain(){inta[101];inti,j,k,l,m;intexchanged;printf("****************************************\n");printf("冒泡排序算法\n");printf("****************************************\n\n");printf("请输入数据列表长度:\n");scanf("%d",&l);printf("\n请输入%d个数字:\n",l);for(i=0;iscanf("%d",&a[i]);i=0;do{exchanged=0;for(j=0;jif(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;exchanged=1;}if(i==0)printf("\n");printf("第%d趟冒泡排序法由小到大排序后:\n",i+1);for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
Bottom=Mid+1;
if(loc==-1)
printf("%d这个数在列表中没有找到。
\n\n",num);
3、插入排序算法
直接插入排序是一种插入排序。
前提:
数组元素a[0]用作哨兵或临时变量,a[1]~a[n]存放n个待排序的元素。
基本思想是:
从a[2]开始,将元素插入到前面已经排好序的有序表中,从而得到一个新的、记录数增加1的有序表。
inti,j,k,l,m;
printf("****************************************\n");
printf("插入排序算法\n");
printf("****************************************\n\n");
printf("请输入数据列表长度:
scanf("%d",&l);
printf("\n请输入%d个数字:
\n",l);
for(i=0;iscanf("%d",&a[i]);for(i=1;i{k=a[i];j=i-1;while((j>=0)&&(a[j]>k)){a[j+1]=a[j];j--;}a[j+1]=k;printf("\n第%d次插入排序后全部数据为:\n",i);for(m=0;m{printf("%d",a[m]);}}printf("\n\n按照插入排序法,你输入的数据由小到大排序为:\n");for(i=0;i{printf("%d",a[i]);}printf("\n");}4、冒泡排序算法#includevoidmain(){inta[101];inti,j,k,l,m;intexchanged;printf("****************************************\n");printf("冒泡排序算法\n");printf("****************************************\n\n");printf("请输入数据列表长度:\n");scanf("%d",&l);printf("\n请输入%d个数字:\n",l);for(i=0;iscanf("%d",&a[i]);i=0;do{exchanged=0;for(j=0;jif(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;exchanged=1;}if(i==0)printf("\n");printf("第%d趟冒泡排序法由小到大排序后:\n",i+1);for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
for(i=1;i{k=a[i];j=i-1;while((j>=0)&&(a[j]>k)){a[j+1]=a[j];j--;}a[j+1]=k;printf("\n第%d次插入排序后全部数据为:\n",i);for(m=0;m{printf("%d",a[m]);}}printf("\n\n按照插入排序法,你输入的数据由小到大排序为:\n");for(i=0;i{printf("%d",a[i]);}printf("\n");}4、冒泡排序算法#includevoidmain(){inta[101];inti,j,k,l,m;intexchanged;printf("****************************************\n");printf("冒泡排序算法\n");printf("****************************************\n\n");printf("请输入数据列表长度:\n");scanf("%d",&l);printf("\n请输入%d个数字:\n",l);for(i=0;iscanf("%d",&a[i]);i=0;do{exchanged=0;for(j=0;jif(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;exchanged=1;}if(i==0)printf("\n");printf("第%d趟冒泡排序法由小到大排序后:\n",i+1);for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
k=a[i];
j=i-1;
while((j>=0)&&(a[j]>k))
a[j+1]=a[j];
j--;
a[j+1]=k;
printf("\n第%d次插入排序后全部数据为:
\n",i);
for(m=0;m{printf("%d",a[m]);}}printf("\n\n按照插入排序法,你输入的数据由小到大排序为:\n");for(i=0;i{printf("%d",a[i]);}printf("\n");}4、冒泡排序算法#includevoidmain(){inta[101];inti,j,k,l,m;intexchanged;printf("****************************************\n");printf("冒泡排序算法\n");printf("****************************************\n\n");printf("请输入数据列表长度:\n");scanf("%d",&l);printf("\n请输入%d个数字:\n",l);for(i=0;iscanf("%d",&a[i]);i=0;do{exchanged=0;for(j=0;jif(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;exchanged=1;}if(i==0)printf("\n");printf("第%d趟冒泡排序法由小到大排序后:\n",i+1);for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
printf("%d",a[m]);
printf("\n\n按照插入排序法,你输入的数据由小到大排序为:
for(i=0;i{printf("%d",a[i]);}printf("\n");}4、冒泡排序算法#includevoidmain(){inta[101];inti,j,k,l,m;intexchanged;printf("****************************************\n");printf("冒泡排序算法\n");printf("****************************************\n\n");printf("请输入数据列表长度:\n");scanf("%d",&l);printf("\n请输入%d个数字:\n",l);for(i=0;iscanf("%d",&a[i]);i=0;do{exchanged=0;for(j=0;jif(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;exchanged=1;}if(i==0)printf("\n");printf("第%d趟冒泡排序法由小到大排序后:\n",i+1);for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
{printf("%d",a[i]);
4、冒泡排序算法
intexchanged;
printf("冒泡排序算法\n");
for(i=0;iscanf("%d",&a[i]);i=0;do{exchanged=0;for(j=0;jif(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;exchanged=1;}if(i==0)printf("\n");printf("第%d趟冒泡排序法由小到大排序后:\n",i+1);for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
i=0;
exchanged=0;
for(j=0;jif(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;exchanged=1;}if(i==0)printf("\n");printf("第%d趟冒泡排序法由小到大排序后:\n",i+1);for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
if(a[j]>a[j+1])
k=a[j];
a[j]=a[j+1];
exchanged=1;
if(i==0)
printf("第%d趟冒泡排序法由小到大排序后:
\n",i+1);
for(m=0;m{printf("%d",a[m]);printf("");}printf("\n");i++;}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
{printf("%d",a[m]);
printf("");
}while(i}5、线性查找算法#include"stdio.h"#include"stdlib.h"typedefstructNode{intr[50];intlength;}list,*sqlist;intCreateSqlist(sqlists){inti;printf("请输入您要进行搜索的数据队列的长度:\n");scanf("%d",&(s->length));printf("\n请输入您要进行搜索的%d个数据:\n",s->length);for(i=0;ilength;i++)scanf("%d",&(s->r[i]));printf("\n");printf("您所输入的数据为:\n");for(i=0;ilength;i++)printf("%-5d",s->r[i]);printf("\n\n");return1;}intSearchSqlist(sqlists,intk){inti=0;s->r[s->length]=k;while(s->r[i]!=k){i++;}if(i==s->length){printf("该表中没有您要查找的数据!\n");return-1;}elsereturni+1;}sqlistInitlist(){sqlistp;p=(sqlist)malloc(sizeof(list));if(p)returnp;elsereturnNULL;}main(){intkeyplace,keynum;sqlistT;printf("****************************************\n");printf("线性查找算法\n");printf("****************************************\n\n");T=Initlist();CreateSqlist(T);printf("请输入您想要查找的数据的关键字:\n");scanf("%d",&keynum);printf("\n");keyplace=SearchSqlist(T,keynum);printf("您要查找的数据的位置为:\n%d\n\n",keyplace);}实验项目2集合与序列一、实验目的(1)掌握并实现判定序列A是否为B的子序列的算法;(2)掌握并实现两个矩阵相乘的算法。二、实验内容1、子序列的判定算法问题描述:两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。算法思想:因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。#include#includeintSubsequence(chars[],chart[]){intm,n,i,j;n=strlen(s);//n表示序列S的长度m=strlen(t);//m表示序列T的长度i=0;j=0;if(m>n)return0;while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
5、线性查找算法
#include"stdio.h"
#include"stdlib.h"
typedefstructNode
{intr[50];
intlength;
}list,*sqlist;
intCreateSqlist(sqlists)
inti;
printf("请输入您要进行搜索的数据队列的长度:
scanf("%d",&(s->length));
printf("\n请输入您要进行搜索的%d个数据:
\n",s->length);
for(i=0;ilength;i++)
scanf("%d",&(s->r[i]));
printf("您所输入的数据为:
printf("%-5d",s->r[i]);
return1;}
intSearchSqlist(sqlists,intk)
inti=0;
s->r[s->length]=k;
while(s->r[i]!
=k)
if(i==s->length)
printf("该表中没有您要查找的数据!
return-1;}
returni+1;
sqlistInitlist()
sqlistp;
p=(sqlist)malloc(sizeof(list));
if(p)
returnp;
returnNULL;}
main()
intkeyplace,keynum;
sqlistT;
printf("线性查找算法\n");
T=Initlist();
CreateSqlist(T);
printf("请输入您想要查找的数据的关键字:
scanf("%d",&keynum);
keyplace=SearchSqlist(T,keynum);
printf("您要查找的数据的位置为:
\n%d\n\n",keyplace);
实验项目2集合与序列
(1)掌握并实现判定序列A是否为B的子序列的算法;
(2)掌握并实现两个矩阵相乘的算法。
1、子序列的判定算法
问题描述:
两个整数序列A=a1,a2,a3,...,am和B=b1,b2,b3,...,bn已经存入两个单链表中,设计一个算法,判断序列B是否是序列A的连续子序列。
算法思想:
因为此题需要判断序列B是否为序列A的子序列,即单链表B中所有连续结点的数据域的值是否在A中能够找到同样连续的一部分。
既然如此,那么我们可以从两个链表的第一个结点开始,若对应的数据相等,则后移指针;最后判断下单链表B是否彻底遍历完成,如果完成,则表示单链表B是单链表A的一个子序列;如果没有遍历完成,则表示单链表B不是单链表A的一个子序列。
intSubsequence(chars[],chart[])
intm,n,i,j;
n=strlen(s);//n表示序列S的长度
m=strlen(t);//m表示序列T的长度
j=0;
if(m>n)
return0;
while((i{if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等i=i+1;j=j+1;}if(i==m)return1;//T是S的子序列return0;}voidmain(){chars[30],t[30];intn,m;printf("**************************************************\n");printf("子序列判定算法\n");printf("**************************************************\n\n");printf("您要在多少组序列中进行判定,请输入(1~100):");scanf("%d",&n);printf("\n");m=1;while(n--){printf("请输入第%d组待匹配序列S:",m);scanf("%s",s);printf("请输入第%d组待匹配序列T:",m);scanf("%s",t);if(Subsequence(s,t)==1)printf("序列T(%s)是序列S(%s)的子序列。\n\n",t,s);elseprintf("序列T(%s)不是序列S(%s)的子序列。\n\n",t,s);m++;}}2、矩阵相乘算法问题描述:实现m*n矩阵和n*p矩阵相乘。m,n,p均小于10,矩阵元素为整数。分析:首先我们可以根据题意写出函数头。可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。因为m,n和p都是未知量,要进行处理的矩阵大小是变量。但我们可以定义比较大的二维数组,只使用其中的部分数组元素。矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。根据矩阵乘法公式:可以用循环直接套用上面的公式计算每个元素。嵌套循环内部进行累加前,一定要注意对累加变量进行清零。1).输入两个矩阵的的行列数m,n,p;2).输入第一个矩阵的每个元素;3).输入第二个矩阵的每个元素;4).调用函数进行乘法运算,结果放在lMatrixResult中;5.)打印输出结果矩阵。#defineMAX10voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]){inti,j,k;longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
if(s[j]==t[i])//序列T中第i个元素与序列S中第j个元素相等
i=i+1;
j=j+1;
if(i==m)
return1;//T是S的子序列
chars[30],t[30];
intn,m;
printf("子序列判定算法\n");
printf("您要在多少组序列中进行判定,请输入(1~100):
m=1;
while(n--)
printf("请输入第%d组待匹配序列S:
",m);
scanf("%s",s);
printf("请输入第%d组待匹配序列T:
scanf("%s",t);
if(Subsequence(s,t)==1)
printf("序列T(%s)是序列S(%s)的子序列。
\n\n",t,s);
printf("序列T(%s)不是序列S(%s)的子序列。
m++;
2、矩阵相乘算法
实现m*n矩阵和n*p矩阵相乘。
m,n,p均小于10,矩阵元素为整数。
分析:
首先我们可以根据题意写出函数头。
可以定为voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX]),其中lMatrix1和lMatrix2分别是输入的m*n矩阵和n*p矩阵,lMatrixResult是输出的m*p矩阵。
因为m,n和p都是未知量,要进行处理的矩阵大小是变量。
但我们可以定义比较大的二维数组,只使用其中的部分数组元素。
矩阵相乘的算法比较简单,输入一个m*n矩阵和一个n*p矩阵,结果必然是m*p矩阵,有m*p个元素,每个元素都需要计算,可以使用m*p嵌套循环进行计算。
根据矩阵乘法公式:
可以用循环直接套用上面的公式计算每个元素。
嵌套循环内部进行累加前,一定要注意对累加变量进行清零。
1).输入两个矩阵的的行列数m,n,p;
2).输入第一个矩阵的每个元素;
3).输入第二个矩阵的每个元素;
4).调用函数进行乘法运算,结果放在lMatrixResult中;
5.)打印输出结果矩阵。
#defineMAX10
voidMatrixMutiply(intm,intn,intp,longlMatrix1[MAX][MAX],
longlMatrix2[MAX][MAX],longlMatrixResult[MAX][MAX])
inti,j,k;
longlSum;/*嵌套循环计算结果矩阵(m*p)的每个元素*/
for(i=0;ifor(j=0;j{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/lSum=0;for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
for(j=0;j
{/*按照矩阵乘法的规则计算结果矩阵的i*j元素*/
lSum=0;
for(k=0;klSum+=lMatrix1[i][k]*lMatrix2[k][j];lMatrixResult[i][j]=lSum;}}main(){longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];longlMatrixResult[MAX][MAX],lTemp;inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/printf("\nPleaseinputmofMatrix1:\n");scanf("%d",&m);printf("PleaseinputnofMatrix1:\n");scanf("%d",&n);printf("PleaseinputpofMatrix2:\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/printf("\nPleaseelementsofMatrix1(%d*%d):\n",m,n);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
lSum+=lMatrix1[i][k]*lMatrix2[k][j];
lMatrixResult[i][j]=lSum;
longlMatrix1[MAX][MAX],lMatrix2[MAX][MAX];
longlMatrixResult[MAX][MAX],lTemp;
inti,j,m,n,p;/*输入两个矩阵的的行列数m,n,p*/
printf("\nPleaseinputmofMatrix1:
scanf("%d",&m);
printf("PleaseinputnofMatrix1:
printf("PleaseinputpofMatrix2:
\n");scanf("%d",&p);/*输入第一个矩阵的每个元素*/
printf("\nPleaseelementsofMatrix1(%d*%d):
\n",m,n);
for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
for(j=0;j{scanf("%ld",&lTemp);lMatrix1[i][j]=lTemp;}/*输入第二个矩阵的每个元素*/printf("\nPleaseelementsofMatrix2(%d*%d):\n",n,p);for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
scanf("%ld",&lTemp);
lMatrix1[i][j]=lTemp;
}/*输入第二个矩阵的每个元素*/
printf("\nPleaseelementsofMatrix2(%d*%d):
\n",n,p);
for(i=0;ifor(j=0;j{scanf("%ld",&lTemp);lMatrix2[i][j]=lTemp;}/*调用函数进行乘法运算,结果放在lMatrixResult中*/MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/printf("\nResultmatrix:\n");for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
lMatrix2[i][j]=lTemp;
}/*调用函数进行乘法运算,结果放在lMatrixResult中*/
MatrixMutiply(m,n,p,lMatrix1,lMatrix2,lMatrixResult);/*打印输出结果矩阵*/
printf("\nResultmatrix:
for(i=0;i{for(j=0;jprintf("%ld",lMatrixResult[i][j]);printf("\n");}} 实验项目3关系与函数一、实验目的(1)掌握并实现关系的复合运算R◦S的算法;(2)熟悉偏序关系的定义,验证相应的性质判定算法。二、实验内容1、关系的复合运算复合运算能由两个二元关系生成一个新的二元关系。设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。关系可用矩阵表示,故复合运算也可用矩阵表示。设有三个集合:X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:MR◦S=MR◦MS=[cij]m×p。实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。#include#defineMAX10voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX]){inti,j,k;intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
printf("%ld",lMatrixResult[i][j]);
实验项目3关系与函数
(1)掌握并实现关系的复合运算R◦S的算法;
(2)熟悉偏序关系的定义,验证相应的性质判定算法。
1、关系的复合运算
复合运算能由两个二元关系生成一个新的二元关系。
设X→Y(R关系),Y→Z(S关系),则称X→Z(R◦S关系)为R和S的复合关系,并规定为:
R◦S={|x∈X∧z∈Z∧∃y(y∈Y∧∈R∧∈S)}。
关系可用矩阵表示,故复合运算也可用矩阵表示。
设有三个集合:
X={x1,x2…xm},Y={y1,y2…yn},Z={z1,z2…zp},X→Y→Z,|X|=m,|Y|=n,|Z|=p,MR=[aik]m×n,MS=[akj]n×p则复合关系R◦S的关系矩阵为:
MR◦S=MR◦MS=[cij]m×p。
实现关系的复合运算R◦S的算法,就是将二元关系用关系矩阵表示,通过两个关系矩阵对应行列元素先进行逻辑乘,后进行逻辑加生成新的关系矩阵中的每一个元素。
新的关系矩阵所对应的二元关系就是两个二元关系复合形成的,编程实现这一复合过程。
voidGetCompositiveRelation(intm,intn,intl,intMatrixA[MAX][MAX],
intMatrixB[MAX][MAX],intMatrixResult[MAX][MAX])
intlSum;//嵌套循环计算结果矩阵(m*l)的每个元素
for(i=0;ifor(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
for(j=0;j{lSum=0;for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
for(k=0;klSum+=MatrixA[i][k]*MatrixB[k][j];MatrixResult[i][j]=lSum;//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵if(MatrixResult[i][j]>0)MatrixResult[i][j]=1;}}voidmain(){intMatrixA[MAX][MAX],MatrixB[MAX][MAX];intMatrixResult[MAX][MAX],Temp;inti,j,m,n,l;char*s,*t;printf("**************************************************\n");printf("复合关系算法\n");printf("**************************************************\n\n");printf("集合X={学生A,学生B,学生C};\nY={离散数学,
lSum+=MatrixA[i][k]*MatrixB[k][j];
MatrixResult[i][j]=lSum;
//矩阵乘积中每个非零项用1替换后,就可得到关系复合的矩阵
if(MatrixResult[i][j]>0)
MatrixResult[i][j]=1;
intMatrixA[MAX][MAX],MatrixB[MAX][MAX];
intMatrixResult[MAX][MAX],Temp;
inti,j,m,n,l;
char*s,*t;
printf("复合关系算法\n");
printf("集合X={学生A,学生B,学生C};\nY={离散数学,
copyright@ 2008-2022 冰豆网网站版权所有
经营许可证编号:鄂ICP备2022015515号-1