《离散数学》实验课程指导书.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～100）：
"）;
scanf（"%d",&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输出数据列表：
\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（"该表中没有您要查找的数据!
\n"）;
else
printf（"您要查找的数是%d，在数据列表中的位序为%d。
\n",num,i）;
}while（num!
=9999）;//若输入的待查找的数不是999，则可持续搜索。
}
2、二分查找算法
折半查找（BinarySearch）：
也称为二分查找。
它的前提是：
1）、线性表中的记录必须是关键字有序（通常是从小到大有序）；2）、线性表必须采用顺序存储。
折半查找的基本思想是：
在有序表中，取中间记录作为比较对象，若给定值与中间记录的关键字相等，则查找成功；若给定值小于中间记录的关键字，则在中间记录的左半区继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区继续查找。
不断反复，直到查找成功；或者直到最后都没有找到，查找失败。
mid计算公式：
mid=（low+high）/2=low+（high-low）/2;
#include
voidmain（）
{
inta[101];
inti,n,num;
intTop,Bottom,Mid;
intflag=1;//如果在列表中找到数字，则值为1，否则为0
intloc=-1;//要查找的数在列表中的位置，如果loca=-1表示列表中没有这个数;如果有这个数,则它的值为所在的位置
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～100）：
"）;
scanf（"%d",&n）;
}
printf（"请您输入第1个整数a[1]:
"）;
scanf（"%d",&a[1]）;
i=2;
while（i<=n）//输入从小到大的表列
{
printf（"请您输入第%d个整数a[%d]:
",i,i）;
scanf（"%d",&a[i]）;
if（a[i]>a[i-1]）
i++;
else
printf（"您输入的数不满足升序要求，请重新输入!
\n"）;}
printf（"\n输出数据列表：
\n"）;
for（i=1;i<=n;i++）
{
printf（"%6d",a[i]）;
}
printf（"\n\n"）;
do
{
printf（"请输入要查找的数：
"）;
scanf（"%d",&num）;
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的有序表。
#include
voidmain（）
{
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、冒泡排序算法
#include
voidmain（）
{
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;}
else
returni+1;
}
sqlistInitlist（）
{
sqlistp;
p=（sqlist）malloc（sizeof（list））;
if（p）
returnp;
else
returnNULL;}
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
#include
intSubsequence（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）;
else
printf（"序列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.）打印输出结果矩阵。
#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
#defineMAX10
voidGetCompositiveRelation（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={离散数学，
升级会员 