利用真值表法求主析取范式及主合取范式地实现.docx
《利用真值表法求主析取范式及主合取范式地实现.docx》由会员分享，可在线阅读，更多相关《利用真值表法求主析取范式及主合取范式地实现.docx（18页珍藏版）》请在冰豆网上搜索。
利用真值表法求主析取范式及主合取范式地实现
实验报告
（/学年第一学期）
课程名称
离散数学
实验名称
利用真值表法求主析取范式及主合取范式的实现
实验时间
年
月
日
指导单位
指导教师
学生姓名
班级学号
学院（系）
专业
实验报告
实验名称
利用真值表法求主析取范式及主合取范式的实现
指导教师
实验类型
上机
实验学时
4
实验时间
一、实验目的和要求
能够列出合式公式的真值表并给出相应主析取范式和主合取范式。
二、实验环境（实验设备）
硬件:
PC机。
软件:
Code:
:
Blocks（C++）
三、实验原理及内容
内容：
编程实现用真值表法求任意含三个以内变量的合式公式的主析取范式和主合取范式。
原理：
首先读入变元个数，然后读入合式公式，用堆栈的知识将中缀表达式转化为后缀表达式，调用否定、析取、合取、条件、双条件的函数计算P、Q、R取不同真值时合式公式的真值，然后输出真值表，调用计算主析取范式和主合取范式的函数并输出。
程序：
#include
#include
#include
#include
usingnamespacestd;
stringOriginalForm;//原式
stringHequ;//主合取范式
stringXiqu;//主析取范式
classSeqStack//建立一个堆栈，利用将中缀表达式转为后缀表达式
{
public:
SeqStack（intmSize）;
~SeqStack（）;
charTop（）;
boolPush（charx）;
boolPop（）;
private:
char*st;
inttop;
intmaxtop;
};
SeqStack:
:
SeqStack（intmSize）
{
maxtop=mSize-1;
top=-1;
st=newchar[mSize];
}
SeqStack:
:
~SeqStack（）
{
delete[]st;
}
charSeqStack:
:
Top（）
{
returnst[top];
}
boolSeqStack:
:
Push（charx）
{
if（top==maxtop）
returnfalse;
st[++top]=x;
returntrue;
}
boolSeqStack:
:
Pop（）
{
if（top==-1）
returnfalse;
top--;
returntrue;
}
intp,q,r,s,t,u;
inta,b,result;
intv=0;
intnumber;//用number表示变元的个数
SeqStackstack（200）;
voidNot（）//否定
{
a=stack.Top（）;
stack.Pop（）;
result=a==1?
0:
1;
stack.Push（result）;
}
voidOr（）//析取
{
result=a+b;
result=result>1?
1:
result;
stack.Push（result）;
}
voidAnd（）//合取
{
result=a*b;
stack.Push（result）;
}
voidIf（）//条件,b->a
{
result=（b==1&&a==0）?
0:
1;
stack.Push（result）;
}
voidDoubleif（）//双条件
{
result=（b==a）?
1:
0;
stack.Push（result）;
}
boolCanIn（charout）//优先级的判断
{
charin=stack.Top（）;
inti,o;
switch（in）
{
case'#':
i=0;break;
case'（':
i=1;break;
case'-':
i=3;break;
case'>':
i=5;break;
case'|':
i=7;break;
case'&':
i=9;break;
case'!
':
i=11;break;
case'）':
i=12;break;
}
switch（out）
{
case'#':
o=0;break;
case'（':
o=12;break;
case'-':
o=2;break;
case'>':
o=4;break;
case'|':
o=6;break;
case'&':
o=8;break;
case'!
':
o=10;break;
case'）':
o=1;break;
}
if（ireturntrue;
else
returnfalse;
}
voidInfixToPostfix（）//中缀表达式转后缀表达式
{
stringtmp="";
stack.Push（'#'）;
for（inti=0;（unsigned）i{
if（OriginalForm[i]=='P'||OriginalForm[i]=='Q'||OriginalForm[i]=='R'||OriginalForm[i]=='S'||OriginalForm[i]=='T'||OriginalForm[i]=='U'）
{
tmp=tmp+OriginalForm[i];
continue;
}
if（CanIn（OriginalForm[i]））
stack.Push（OriginalForm[i]）;
elseif（OriginalForm[i]=='）'）
{
while（stack.Top（）!
='（'）
{
tmp=tmp+stack.Top（）;
stack.Pop（）;
}
stack.Pop（）;
}
else
{
do
{
tmp=tmp+stack.Top（）;
stack.Pop（）;
}while（!
CanIn（OriginalForm[i]））;
stack.Push（OriginalForm[i]）;
}
}
while（stack.Top（）!
='#'）
{
tmp=tmp+stack.Top（）;
stack.Pop（）;
}
stack.Pop（）;
OriginalForm=tmp;
}
voidCalculate（）//计算主析取范式和主合取范式的函数
{
if（number==3）
{
for（inti=0;（unsigned）i{
if（OriginalForm[i]=='P'||OriginalForm[i]=='Q'||OriginalForm[i]=='R'）
{
v=OriginalForm[i]=='P'?
p:
OriginalForm[i]=='Q'?
q:
r;
stack.Push（v）;
continue;
}
if（OriginalForm[i]!
='!
'）
{
a=stack.Top（）;
stack.Pop（）;
b=stack.Top（）;
stack.Pop（）;
}
switch（OriginalForm[i]）
{
case'-':
Doubleif（）;break;
case'>':
If（）;break;
case'|':
Or（）;break;
case'&':
And（）;break;
case'!
':
Not（）;break;
}
}
}
if（number==2）
{
for（inti=0;（unsigned）i{
if（OriginalForm[i]=='P'||OriginalForm[i]=='Q'）
{
v=OriginalForm[i]=='P'?
p:
q;
stack.Push（v）;
continue;
}
if（OriginalForm[i]!
='!
'）
{
a=stack.Top（）;
stack.Pop（）;
b=stack.Top（）;
stack.Pop（）;
}
switch（OriginalForm[i]）
{
case'-':
Doubleif（）;break;
case'>':
If（）;break;
case'|':
Or（）;break;
case'&':
And（）;break;
case'!
':
Not（）;break;
}
}
}
}
voidPrint（）
{
if（number==3）
{
cout<<"P\t"<<"Q\t"<<"R\t"<<"Z"<for（p=1;p>=0;p--）
{
for（q=1;q>=0;q--）
{
for（r=1;r>=0;r--）
{
Calculate（）;
if（result==1）
Xiqu=Xiqu+"（"+（p==1?
"P":
"!
P"）+"&"+（q==1?
"Q":
"!
Q"）+"&"
+（r==1?
"R":
"!
R"）+"）"+"|";
else
Hequ=Hequ+"（"+（p==0?
"P":
"!
P"）+"|"+（q==0?
"Q":
"!
Q"）+"|"
+（r==0?
"R":
"!
R"）+"）"+"&";
cout<}
}
}
}
if（number==2）
{
cout<<"P\t"<<"Q\t"<<"Z"<for（p=1;p>=0;p--）
{
for（q=1;q>=0;q--）
{
Calculate（）;
if（result==1）
Xiqu=Xiqu+"（"+（p==1?
"P":
"!
P"）+"&"+（q==1?
"Q":
"!
Q"）+"）"+"|";
else
Hequ=Hequ+"（"+（p==0?
"P":
"!
P"）+"|"+（q==0?
"Q":
"!
Q"）+"）"+"&";
cout<}
}
}
cout<if（Xiqu.length（）!
=0）
Xiqu.erase（Xiqu.length（）-2）;
if（Hequ.length（）!
=0）
Hequ.erase（Hequ.length（）-2）;
cout<<"主析取范式：
"<cout<<"主合取范式：
"<}
intmain（）
{
intflag=1;
while（flag==1）
{
SetConsoleTextAttribute（GetStdHandle
（STD_OUTPUT_HANDLE）,FOREGROUND_INTENSITY
|FOREGROUND_GREEN|FOREGROUND_BLUE）;
//设置绿色和蓝色相加（即青色）
system（"cls"）;//清屏
cout<<"-----------------"<cout<<"欢迎使用！
"<cout<<"!
表示否定"<cout<<"|表示析取"<cout<<"&表示合取"<cout<<">表示条件"<cout<<"-表示双条件"<cout<<"-----------------"<cout<";
cin>>number;
cout<<"请输入合式公式：
";
switch（number）
{
case2:
cout<case3:
cout<}
charstr[100];
cin>>str;
OriginalForm=str;
InfixToPostfix（）;
Print（）;
cout<（继续请按1，退出请按0）:
";
cin>>flag;
}
return0;
}
流程图：
Y
N
举例使用：
四、实验小结（包括问题和解决方法、心得体会、意见与建议等）
刚开始思考如何写这个程序的时候，我不知道该如何处理输入进来的合式公式，在翻阅了数据结构书籍之后我才忽然反应过来，可以用堆栈的知识，将输入进来的中缀表达式转化为后缀表达式，这样就方便计算合式公式的真值了。
这次离散数学实验中，我成功地将所学习得C++的编程知识和数据结构里的堆栈的知识运用了起来，虽然中途遇到了一些困难，但最终都很好地解决了。
这次实验让我学会了利用编程语言来求主析取范式和主合取范式，更加深刻地理解了这两种范式，并且也让我对C、C++等编程语言有了更强的运用能力，让我明白了离散数学和编程知识是息息相关、密不可分的。
以后我将更加认真学习离散数学，并且更多地将编程的知识运用起来。
五、指导教师评语
成绩
批阅人
日期
升级会员 