编译原理实验报告3Word下载.docx
《编译原理实验报告3Word下载.docx》由会员分享，可在线阅读，更多相关《编译原理实验报告3Word下载.docx（26页珍藏版）》请在冰豆网上搜索。
=M（B,aa）
=M（M（B,a）,a）
=M（A,a）
=Z
该符号串能被有穷状态所接受！
B:
=b
输入规则：
Z:
=AbZ:
=BaZ:
=ZcA:
=aB:
=Ab
文法规则存储完毕！
此为非确定有穷状态自动机！
NFAN=（{Z,B,A},{b,a,c},M,{S},{Z}）
M（A,a）=$
M（A,b）={Z,B}
M（A,c）=$
M（B,a）={Z,A}
M（B,b）=$
M（B,c）=$
M（Z,a）=$
M（Z,b）=$
M（Z,c）={Z}
M（S,a）={A}
M（S,b）={B}
M（S,c）=$
将NFA转化为DFA!
DFAN'
=（{[S],[B],[A],[AZ],[BZ],[Z]},{[b],[a],[c]},M'
[S],F'
）
其中M'
M'
（[S],b）=[B]
（[S],a）=[A]
（[B],a）=[AZ]
（[A],b）=[BZ]
（[AZ],b）=[BZ]
（[AZ],c）=[Z]
（[BZ],a）=[AZ]
（[BZ],c）=[Z]
（[Z],c）=[Z]其中F'
={[AZ],[BZ],[Z]}输入要推导的字符串:
ababc
（[S],ababc）=M'
（M'
（[S],a）,babc）=M'
（[A],babc）=M'
（[A],b）,abc）=M'
（[BZ],abc）=M'
（[BZ],a）,bc）=M'
（[AZ],bc）=M'
（[AZ],b）,c）=M'
（[BZ],c）=[Z]
[Z]属于终止状态集合！
该字符串能被有穷状态所接受
实验结果:
abah曰**zB-AAh-BTn=-三=--==
szzzBBAA
一屉£
]赶；
□皿d血a屉!
JRdEi
法规则存储完毕¥
此为确定有穷状态自动机，
DFA
箕中Fl：
M<
Z,a>
B,b>
B,a>
=A
A,a>
ft,b>
=B
MCS.h>
S,a>
-n
生危fa请
退出请捋m请输入要推导的符号串:
ababaaMC£
rababaa>
=MCM<
habaa>
=M<
A,babaa^=MCI1<
A,b>
^lbaa>
=MCB.abaa>
.baa5=MCArbaa）-rKM<
A,h>
aa>
B,aaJ
=M<
A.a>
競符号串能被有穷状态所接受*
bacab
8ABzBaAb-一=一=■一一一一s
数gZ:
A:
B;
w则则则则则则则
—f畐m-劈___鸟-a_=&
g^
生遽巒
运行m请按2退岀雷霽一
花为非确定有穷状态自动机？
UFAH-«
Z,B.A>
.<
b,a,c>
M.<
S>
<
Z»
Mnpn：
n<
fi,a>
=$
B,c>
tt<
Z„b>
Z,c>
=<
Z>
HCE,a>
-<
A>
S,b>
B>
n<
s,c>
=$将NPA转牝为DFfHDFAN1=«
[SJ,LB],Eft],[AZ],LBZJ,tai,Lc]>
MJ,[S],FJ>
其中护:
C[Sl,b>
=*[B]
HJC[B],a>
-CAZl
MJ<
rA],b>
=EBZJ
NJ<
lAZl,c>
=[ZJ
M1<
LBZJ,a>
=tAZJ
NJC[BZl,c>
-rZl
mj<
rzj4Fc>
=iZ]
其中F，=<
[fiZJ,LBZJ,czn
生成曲
f青输入要推导的字符串=ababc
NfC[S],abalK>
=MJ<
Mf<
[SJ,a>
babc>
-Mf<
[A],babc>
rAJ,b>
abc>
WIB却“be〉
LAZlRbc>
MJ<
M,<
[AZEb>
.c>
EBZl,c>
-[Z]
参考程序
#include<
iostream.h>
String.h>
structLeftitem;
structRightNode//存储状态转换关系中弧与终止状态结点结构
{
chartran;
charnextstate;
RightNode*nextsibling;
RightNode（charx,chary）
tran=x;
nextstate=y;
nextsibling=NULL;
}
};
structLeftitem//存储状态转换关系中初始状态结点结构
charstate;
RightNode*link;
〃存放确定化的NFA状态结点结构
structStateitem
charnewstates[10];
Stateitem（）
newstates[0]='
\0'
;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////intCheckState（LeftltemArray[],intsize）
RightNode*p;
RightNode*q;
for（inti=0;
i<
size;
i++）
p=Array[i].link;
q=p->
nextsibling;
if（q==NULL）return1;
while（q!
=NULL）
if（p_>
tran==q_>
tran）return0;
q=q->
return1;
}intCheckExist（StateltemSArray[],int&
length,chartemp[]）
//将NFA确定化创建二维矩阵时判别新产生的状态是否在状态数组中存储过
inti=0,k,m;
while（i<
=length）
if（strlen（SArray[i].newstates）==strlen（temp））
if（strcmp（SArray[i].newstates,temp）==0）
k=i;
break;
i++;
if（i>
length）
length++;
m=length;
returnm;
else
returnk;
intgetcount1（LeftltemArray[],intsize）//取得FA中状态的个数
chartemp[20];
intlen=0,count=0;
inti,j;
RightNode*pNode;
for（i=0;
pNode=Array[i].link;
while（pNode）
for（j=0;
j<
len;
j++）
if（pNode->
nextstate==temp[j]）break;
if（j==len）
count++;
temp[len]=pNode->
nextstate;
len++;
pNode=pNode->
returncount;
intgetcount2（LeftltemArray[],intsize）//取得FA中输入字母的个数
tran==temp[j]）break;
tran;
intgetstate（RightNode*pNode,chararc）〃判定一个状态是否能通过一条弧进入下一状态
tran==arc）return1;
return0;
voidSort（charA[],intn）//将取得的新状态进行排序
for（inti=n_1;
i>
0;
i__）
for（intj=O;
i;
if（A[j+1]<
A[j]）
chartemp=A[j+1];
A[j+1]=A[j];
A[j]=temp;
voidBianli1（LeftltemArray[],intsize）〃输出FA中有穷非空的状态集合
intlen=0;
if（len==0）cout«
pNode->
cout<
v"
"
vvpNode->
voidBianli2（LeftltemArray[],intsize）
〃输岀FA中有穷的输入字母表
else
tran;
len++;
}pNode=pNode->
}voidBianli31（LeftItemArray[],intsize）
〃输岀DFA状态转换关系的集合M{
inti;
while（pNode!
coutvv"
M（"
v<
Array[i].statevv"
tran
vv"
）="
nextstate<
vendl;
voidBianli32（LeftltemArray[],intsize）〃输出NFA状态转换关系集合M
charK[20];
RightNode*qNode;
tran==K[j]）break;
K[len]=pNode->
Sort（K,len）;
cout«
"
vvK[j]vv"
if（getstate（pNode,K[j]））
<
{"
tran==K[j]）
qNode=pNode->
while（qNode）
if（qNode->
vvqNode->
qNode=qNode->
}"
endl;
$"
vvendl;
TArray[]
voidlnitiate（LeftltemArray[],intsize,charTArray[]）〃将FA中的输入字母表存入数组
ivsize;
jvlen;
tran==TArray[j]）break;
TArray[len]=pNode->
}voidGetState（LeftltemArray[],intsize,charnstate[],chararc,chartemp[]）//将NFA确定化创建二维矩阵时取得新状态
inti=0;
while（nstate[i]!
='
for（intj=0;
jvsize;
if（Array[j].state==nstate[i]）
RightNode*p=Array[j].link;
while（p!
tran==arc）
intk=0;
while（temp[k]!
if（p->
nextstate==temp[k]）break;
k++;
if（temp[k]=='
temp[k]=p->
temp[k+1]='
\0：
p=p->
}voidChange（StateltemSArray[],chartemp[],int&
length,intMArray[][20],intindex,inti）
//取得新状态后对状态数组以及状态转换矩阵进行对应变化
intk;
if（temp[0]!
k=CheckExist（SArray,length,temp）;
MArray[index][i]=k;
if（k==length）
strcpy（SArray[length].newstates,temp）;
charFindNewState（LeftltemArray[],intsize,charS,chararc）//得到当前状态的下一状态
if（Array[i].state==S）
RightNode*p=Array[i].link;
tran==arc）returnp->
p=p->
returnNULL;
//取得输入字母在字母表中的下表
}intFindy（charTArray[],chars）
while（TArray[i]!
if（TArray[i]==s）returni;
i++;
}voidCreateFA1（LeftltemArray[],intsize,charstart,charend）
//根据输入文法创建FA{
if（CheckState（Array,size））
此为确定有穷状态自动机!
DFAD=（"
此为非确定有穷状态自动机!
NFAN=（"
Bianli1（Array,size）;
},{"
Bianli2（Array,size）;
},M,"
coutvvstart;
elsecout<
vvstartvv"
coutvv"
endvv"
}）"
其中M:
if（CheckState（Array,size））Bianli31（Array,size）;
Bianli32（Array,size）;
length,int
}voidCreateFA2（LeftltemArray[],intsize,charstart,charend,StateltemSArray[],charTArray[],int&
MArray[][20]）
//将NFA转换为DFA
intindex=0;
do
i=0;
temp[0]='
GetState（Array,size,SArray[index].newstates,TArray[i],temp）;
Sort（temp,strlen（temp））;
Change（SArray,temp,length,MArray,index,i）;
index++;
}while（index<
=length）;
voidDisplay（StateItemSArray[],charTArray[],intMArray[][20],intx,inty,charstart,charend）
〃输出确定化的NFA
inti,j,k;
将NFA转化为DFA!
=（{"
ivx;
if（i==0）coutvv"
["
vvSArray[i].newstatesvv"
]"
elsecoutvv"
["
ivy;
if（i==O）coutv<
TvvTArray[i]vv"
TArray[i]vv"
},M'
startvv"
],F'
）"
其中M'
x;
jvy;
if（MArray[i][j]!
=-1）
k=MArray[i][j];
（["
],"
vvTArray[j]vv"
）=["
vvSArray[k].newstatesvv"
其中F'
={"
k=0;
j=0;
while（SArray[i].newstates[j]!
if（SArray[i].newstates[j]==end）break;
j++;
if（SArray[i].newstates[j]!
if（k==0）coutvv"
k++;
voidRunFA1（LeftltemArray[],intsize,charstart,charend）
charTD[20];
inti=0,j;
chars=start;
COUt«
请输入要推导的符号串：
；
cin»
TD;
svv"
TD[j]!
TD[j];
endl;
while（TD[i]!
if（TD[i+1]!
cout
升级会员 