安徽大学编译原理试验斯.docx
《安徽大学编译原理试验斯.docx》由会员分享，可在线阅读，更多相关《安徽大学编译原理试验斯.docx（22页珍藏版）》请在冰豆网上搜索。
安徽大学编译原理试验斯
不确定的有穷自动机的化简
2015年11月25日星期三
班级：
软件工程学号：
E21314003姓名：
李世
1.目的与要求
通过设计、编写和调试，将不确定的有穷自动机转换为与之等价的确定的有穷自动机的程序，使学生了解子集法。
掌握转换过程中的相关概念和方法。
DFA的表现形式可以是表格或图形。
2.理论基础
有穷自动机（也称有限自动机）作为一种识别装置，它能准确地识别正规集，即识别正规式所表示的集合.应用有穷自动机这个理论，为词法分析程序的自动构造寻找有效的方法和工具。
有穷自动机分为两类，即，确定的有穷自动机（DeterministicFiniteAutomata）和不确定的有穷自动机（NondeterministicFiniteAutomata）。
（1）不确定的有穷自动机的定义：
一个不确定的有穷自动机（NFA）M是一个五元组：
NFAM={K，Σ，f，S，Z}，
其中:
K为状态的有穷非空集;
Σ为有穷输入字母表;
f为K×Σ*到K的子集（2K）的一种映射,2K表示K的幂集（f不是一个单值函数）;
S⊆K是初始状态集;
Z⊆K为终止状态集.
例子:
NFAM=（{S，P，Z}，{0，1}，f，{S，P}，{Z}），其中：
f（S，0）={P}//函数的结果为集合
f（S，1）={S，Z}
f（P，1）={Z}
f（Z，0）={P}
f（Z，1）={P}
状态图表示为：
矩阵表示为：
（2）确定的有穷自动机的定义：
一个确定的有穷自动机（DFA）M是一个五元组：
M=（K，Σ，f，S，Z）
其中:
K是一个有穷集，它的每个元素称为一个状态；
Σ是一个有穷字母表，它的每个元素称为一个输入符号，所以也称Σ为输入符号表；
f是转换函数，是在K×Σ→K上的映射，即，如f（ki，a）=kj，（ki∈K，kj∈K）就意味着，当前状态为ki，输入符为a时，将转换为下一个状态kj，我们把kj称作ki的一个后继状态；
S∈K是唯一的一个初态；
Z⊂K是一个终态集，终态也称可接受状态或结束状态。
例子:
DFAM=（{S，U，V，Q}，{a，b}，f，S，{Q}），其中f定义为：
f（S，a）=Uf（V，a）=U
f（S，b）=Vf（V，b）=Q
f（U，a）=Qf（Q，a）=Q
f（U，b）=Vf（Q，b）=Q
状态图表示为：
矩阵表示为：
（3）确定有限自动机和不确定有限自动机
DFA是NFA的特例。
对每个NFAN一定存在一个DFAＭ，使得L（M）=L（N）。
对每个NFAN存在着与之等价的DFAM。
有一种算法，将NFA转换成接受同样语言的DFA.这种算法称为子集法.
子集法的基本思想：
让DFA的每一个状态对应NFA的一组状态，也就是让DFA使用它的状态去记录在NFA读入一个输入符号后可能达到的所有状态。
注意：
与某一NFA等价的DFA不唯一.
a）定义对状态集合I的几个有关运算：
状态集合I的ε-闭包：
表示为ε-closure（I），定义为一状态集，是状态集I中的任何状态S经任意条ε弧而能到达的状态的集合。
状态集合I中的任何状态S都属于ε-closure（I）。
状态集合I的a弧转换：
表示为move（I,a）定义为状态集合J，其中J是所有那些可从I中的某一状态经过一条a弧而到达的状态的全体。
三、调试测试
四、程序源代码
#include
#include
#defineMAXS100
usingnamespacestd;
stringNODE;
stringCHANGE;
intN;
structedge
{
stringfirst;
stringchange;
stringlast;
};
structchan
{
stringltab;
stringjihe[MAXS];
};
voidkong（inta）
{
inti;
for（i=0;icout<<'';
}
//排序
voidpaixu（string&a）
{
inti,j;
charb;
for（j=0;jfor（i=0;iif（NODE.find（a[i]）>NODE.find（a[i+1]））
{
b=a[i];
a[i]=a[i+1];
a[i+1]=b;
}
}
voideclouse（charc,string&he,edgeb[]）
{
intk;
for（k=0;k{
if（c==b[k].first[0]）
if（b[k].change=="*"）
{
if（he.find（b[k].last）>he.length（））
he+=b[k].last;
eclouse（b[k].last[0],he,b）;
}
}
}
voidmove（chan&he,intm,edgeb[]）
{
inti,j,k,l;
k=he.ltab.length（）;
l=he.jihe[m].length（）;
for（i=0;ifor（j=0;jif（（CHANGE[m]==b[j].change[0]）&&（he.ltab[i]==b[j].first[0]））
if（he.jihe[m].find（b[j].last[0]）>he.jihe[m].length（））
he.jihe[m]+=b[j].last[0];
for（i=0;ifor（j=0;jif（（CHANGE[m]==b[j].change[0]）&&（he.jihe[m][i]==b[j].first[0]））
if（he.jihe[m].find（b[j].last[0]）>he.jihe[m].length（））
he.jihe[m]+=b[j].last[0];
}
//输出
voidoutputfa（intlen,inth,chan*t）
{
inti,j,m;
cout<<"I";
for（i=0;icout<<'I'<cout<for（i=0;i{
cout<<''<m=t[i].ltab.length（）;
for（j=0;j{
kong（8-m）;
m=t[i].jihe[j].length（）;
cout<}
cout<}
}
voidmain（）
{
edge*b=newedge[MAXS];
inti,j,k,m,n,h,x,y,len;
boolflag;
stringjh[MAXS],endnode,ednode,sta;
cout<<"********************************************"<cout<<"*页式地址重定位模拟*"<cout<<"*作者：
李世E21314003*"<cout<<"*13级软件工程*"<cout<<"********************************************"<
cout<<"请输入NFA各边信息（起点条件[空为*]终点），以#结束：
"<for（i=0;i{
cin>>b[i].first;
if（b[i].first=="#"）break;
cin>>b[i].change>>b[i].last;
}N=i;/*for（j=0;jfor（i=0;i{
if（NODE.find（b[i].first）>NODE.length（））
NODE+=b[i].first;
if（NODE.find（b[i].last）>NODE.length（））
NODE+=b[i].last;
if（（CHANGE.find（b[i].change）>CHANGE.length（））&&（b[i].change!
="*"））
CHANGE+=b[i].change;
}
len=CHANGE.length（）;
cout<<"结点中属于终态的是：
"<cin>>endnode;
for（i=0;iif（NODE.find（endnode[i]）>NODE.length（））
{
cout<<"所输终态不在集合中，错误！
"<return;
}//cout<<"endnode="<chan*t=newchan[MAXS];
t[0].ltab=b[0].first;
h=1;
eclouse（b[0].first[0],t[0].ltab,b）;//求e-clouse
//cout<for（i=0;i{
for（j=0;jfor（m=0;meclouse（t[i].ltab[j],t[i].jihe[m],b）;//求e-clouse
for（k=0;k{//cout<";
move（t[i],k,b）;//求move（I,a）
//cout<for（j=0;jeclouse（t[i].jihe[k][j],t[i].jihe[k],b）;//求e-clouse
}
for（j=0;j{
paixu（t[i].jihe[j]）;//对集合排序以便比较
for（k=0;k{
flag=operator==（t[k].ltab,t[i].jihe[j]）;
if（flag）
break;
}
if（!
flag&&t[i].jihe[j].length（））
t[h++].ltab=t[i].jihe[j];
}
}
cout<"<outputfa（len,h,t）;//输出状态转换矩阵
//状态重新命名
string*d=newstring[h];
NODE.erase（）;
cout<"<for（i=0;i{
sta=t[i].ltab;
t[i].ltab.erase（）;
t[i].ltab='A'+i;
NODE+=t[i].ltab;
cout<<'{'<for（j=0;jif（sta.find（endnode[j]）d[1]=ednode+=t[i].ltab;
for（k=0;kfor（m=0;mif（sta==t[k].jihe[m]）
t[k].jihe[m]=t[i].ltab;
}
for（i=0;iif（ednode.find（NODE[i]）>ednode.length（））
d[0]+=NODE[i];
endnode=ednode;
cout<"<outputfa（len,h,t）;//输出DFA
cout<<"其中终态为：
"<m=2;
sta.erase（）;
flag=0;
for（i=0;i{
//cout<<"d["<for（k=0;k{
//cout<<"I"<y=m;
for（j=0;j{
for（n=0;n{
if（d[n].find（t[NODE.find（d[i][j]）].jihe[k]））
{
if（t[NODE.find（d[i][j]）].jihe[k].length（）==0）
x=m;
else
x=n;
if（!
sta.length（））
{
sta+=x+48;
}
else
if（sta[0]!
=x+48）
{
d[m]+=d[i][j];
flag=1;
d[i].erase（j,1）;//cout<j--;
}
break;//跳出n
}
}//n
}//j
if（flag）
{
m++;
flag=0;
}//cout<<"sta="<sta.erase（）;
}//k
}//i
cout<";
for（i=0;icout<<"{"<cout<chan*md=newchan[m];
NODE.erase（）;
cout<"<for（i=0;i{
md[i].ltab='A'+i;
NODE+=md[i].ltab;
cout<<"{"<}
for（i=0;ifor（k=0;kfor（j=0;j{
if（d[i][0]==t[j].ltab[0]）
{
for（n=0;n{
if（!
t[j].jihe[k].length（））
break;
else
if（d[n].find（t[j].jihe[k]）{
md[i].jihe[k]=md[n].ltab;
break;
}
}
break;
}
}
ednode.erase（）;
for（i=0;ifor（j=0;jif（d[i].find（endnode[j]）ednode+=md[i].ltab;
endnode=ednode;
cout<"<outputfa（len,m,md）;
cout<<"其中终态为：
"<}
升级会员 