编译原理实验四.docx

编译原理实验四.docx

《编译原理实验四.docx》由会员分享，可在线阅读，更多相关《编译原理实验四.docx（18页珍藏版）》请在冰豆网上搜索。

编译原理实验四

编译原理实验报告

实验名称NFA转换为DFA

实验时间2014-5-18

院系计算机科学与技术学院

班级

学号

姓名

1.试验目的

不确定有限状态自动机的确定化（Affirmationoftheindefinitelyfiniteautomata）

2.实验原理

一个确定的有限自动机（DFA）M可以定义为一个五元组，M＝（K，∑，F，S，Z），其中：

（1）K是一个有穷非空集，集合中的每个元素称为一个状态；

（2）∑是一个有穷字母表，∑中的每个元素称为一个输入符号；

（3）F是一个从K×∑→K的单值转换函数，即F（R，a）＝Q，（R，Q∈K）表示当前状态为R，如果输入字符a，则转到状态Q，状态Q称为状态R的后继状态；

（4）S∈K，是惟一的初态；

（5）Z

K，是一个终态集。

由定义可见，确定有限自动机只有惟一的一个初态，但可以有多个终态，每个状态对字母表中的任一输入符号，最多只有一个后继状态。

对于DFAM，若存在一条从某个初态结点到某一个终态结点的通路，则称这条通路上的所有弧的标记符连接形成的字符串可为DFAM所接受。

若M的初态结点同时又是终态结点，则称ε可为M所接受（或识别），DFAM所能接受的全部字符串（字）组成的集合记作L（M）。

一个不确定有限自动机（NFA）M可以定义为一个五元组，M＝（K，∑，F，S，Z），其中：

（1）k是一个有穷非空集，集合中的每个元素称为一个状态；

（2）∑是一个有穷字母表，∑中的每个元素称为一个输入符号；

（3）F是一个从K×∑→K的子集的转换函数；

（4）S

K，是一个非空的初态集；

（5）Z

K，是一个终态集。

由定义可见，不确定有限自动机NFA与确定有限自动机DFA的主要区别是：

（1）NFA的初始状态S为一个状态集，即允许有多个初始状态；

（2）NFA中允许状态在某输出边上有相同的符号，即对同一个输入符号可以有多个后继状态。

即DFA中的F是单值函数，而NFA中的F是多值函数。

因此，可以将确定有限自动机DFA看作是不确定有限自动机NFA的特例。

和DFA一样，NFA也可以用矩阵和状态转换图来表示。

对于NFAM，若存在一条从某个初态结点到某一个终态结点的通路，则称这条通路上的所有弧的标记（ε除外）连接形成的字符串可为M所接受。

NFAM所能接受的全部字符串（字）组成的集合记作L（M）。

由于DFA是NFA的特例，所以能被DFA所接受的符号串必能被NFA所接受。

设M1和M2是同一个字母集∑上的有限自动机，若L（M1）＝L（M2），则称有限自动机M1和M2等价。

由以上定义可知，若两个自动机能够接受相同的语言，则称这两个自动机等价。

DFA是NFA的特例，因此对于每一个NFAM1总存在一个DFAM2，使得L（M1）＝L（M2）。

即一个不确定有限自动机能接受的语言总可以找到一个等价的确定有限自动机来接受该语言。

NFA确定化为DFA

同一个字符串α可以由多条通路产生，而在实际应用中，作为描述控制过程的自动机，通常都是确定有限自动机DFA，因此这就需要将不确定有限自动机转换成等价的确定有限自动机，这个过程称为不确定有限自动机的确定化，即NFA确定化为DFA。

下面介绍一种NFA的确定化算法，这种算法称为子集法：

（1）若NFA的全部初态为S1，S2，…，Sn，则令DFA的初态为：

S＝[S1，S2，…，Sn]，

其中方括号用来表示若干个状态构成的某一状态。

（2）设DFA的状态集K中有一状态为[Si，Si+1，…，Sj]，若对某符号a∈∑，在NFA中有F（{Si，Si+1，…，Sj}，a）={Si’，Si+1’，…，Sk’}

则令F（{Si，Si+1，…，Sj}，a）={Si’，Si+1’，…，Sk’}为DFA的一个转换函数。

若[Si’，Si+1’，…，Sk‘]不在K中，则将其作为新的状态加入到K中。

（3）重复第2步，直到K中不再有新的状态加入为止。

（4）上面得到的所有状态构成DFA的状态集K，转换函数构成DFA的F，DFA的字母表仍然是NFA的字母表∑。

（5）DFA中凡是含有NFA终态的状态都是DFA的终态。

对于上述NFA确定化算法——子集法，还可以采用另一种操作性更强的描述方式，下面我们给出其详细描述。

首先给出两个相关定义。

假设I是NFAM状态集K的一个子集（即I∈K），则定义ε-closure（I）为：

（1）若Q∈I，则Q∈ε-closure（I）；

（2）若Q∈I，则从Q出发经过任意条ε弧而能到达的任何状态Q’，则Q’∈ε-closure（I）。

状态集ε-closure（I）称为状态I的ε闭包。

假设NFAM＝（K，∑，F，S，Z），若I∈K，a∈∑，则定义Ia＝ε-closure（J），其中J是所有从ε-closure（I）出发，经过一条a弧而到达的状态集。

NFA确定化的实质是以原有状态集上的子集作为DFA上的一个状态，将原状态间的转换为该子集间的转换，从而把不确定有限自动机确定化。

经过确定化后，状态数可能增加，而且可能出现一些等价状态，这时就需要简化。

3.实验内容

输入：

非确定有限（穷）状态自动机。

输出：

确定化的有限（穷）状态自动机

4.实验心得

此次实验采用了java可视化的界面来编程的，编程的主要思想是：

首先构造NFA的状态的子集的算法，再来计算ε-closure。

完成这些子模块的设计后，再通过某一中间模块的总控程序对其调用，最后再由主程序总调用，也就实现了NFA转化为其等价的DFA，接下来就是在实现DFA的化简，最后加以验证，经多次代码的修改成型。

通过实验，我可以更好的掌握了NFA到DFA的转化的原理。

5.实验代码与结果

5.1实验运行结果截图如下：

左侧为输入的每个NFA的每个状态，右侧为显示的结果，显示了子集个数，和由NFA构造的·DFA状态。

5.2代码：

packagewy;

importjava.awt.Graphics;

importjava.awt.Graphics2D;

importjava.awt.Image;

importjava.awt.Toolkit;

importjava.awt.event.ActionEvent;

importjava.awt.event.ActionListener;

importjava.util.ArrayList;

importjavax.swing.*;

classNode{//每一个结点包含的有以该结点为起始的整条边的信息：

Stringdata;//本结点值

Stringcondition;//条件值空符号串用ε表示

Stringnext;//指向下一个结点的结点值

Node（Stringd）//终止结点

{

data=d;

condition=null;

next=null;

}

Node（Stringd,Stringc,Strings）//非终止结点

{

data=d;

condition=c;

next=s;//下一个结点的值

}

}

publicclassNFA_DFAextendsJFrame{

publicstaticvoidmain（String[]args）{

NFA_DFAnfa_dfa=newNFA_DFA（）;

nfa_dfa.NFA_DFA（）;

}

publicJLabeljl0=newJLabel（"----每条边的信息如下：

----------------"）;

publicJLabeljl_start=newJLabel（"起点状态:

"）;

publicJLabeljl_condition=newJLabel（"条件:

"）;

publicJLabeljl_end=newJLabel（"终点状态:

"）;

publicJTextFieldjtf_start=newJTextField（）;

publicJTextFieldjtf_condition=newJTextField（）;

publicJTextFieldjtf_end=newJTextField（）;

publicJButtonjbt0=newJButton（"确定"）;

publicJLabeljl_start0=newJLabel（"初态:

"）;

publicJLabeljl_end0=newJLabel（"终态:

"）;

publicJButtonjbt1=newJButton（"确定"）;

publicJTextFieldjtf_start0=newJTextField（）;

publicJTextFieldjtf_end0=newJTextField（）;

publicJTextAreajta_display=newJTextArea（）;

publicJScrollPanesta1=newJScrollPane（jta_display）;

publicJButtonjbt_result=newJButton（"结果显示"）;

publicJTextAreajta_display1=newJTextArea（）;

publicJScrollPanesta2=newJScrollPane（jta_display1）;

publicArrayListnode=newArrayList（）;//非终止结点

publicArrayListnode_end=newArrayList（）;//终止结点

publicArrayListcondition=newArrayList（）;//条件符号

publicArrayList>C=newArrayList>（）;//子集族C

publicArrayListCC=newArrayList（）;//重命名的C

publicStringstart0;//初态值

publicvoidNFA_DFA（）{

this.setTitle（"NFA转换为DFA----WY"）;

this.setContentPane（newMyPanel5（））;

this.setLayout（null）;

this.setSize（700,700）;

jl_start0.setBounds（150,35,70,30）;

add（jl_start0）;

jtf_start0.setBounds（200,35,120,30）;

add（jtf_start0）;

jl_end0.setBounds（350,35,70,30）;

add（jl_end0）;

jtf_end0.setBounds（400,35,120,30）;

add（jtf_end0）;

jbt1.setBounds（555,35,60,30）;

add（jbt1）;

jl0.setBounds（200,80,200,30）;

add（jl0）;

jl_start.setBounds（145,110,70,30）;

add（jl_start）;

jl_condition.setBounds（300,110,50,30）;

add（jl_condition）;

jl_end.setBounds（445,110,70,30）;

add（jl_end）;

jtf_start.setBounds（130,140,80,30）;

add（jtf_start）;

jtf_condition.setBounds（280,140,80,30）;

add（jtf_condition）;

jtf_end.setBounds（430,140,80,30）;

add（jtf_end）;

jbt0.setBounds（555,140,60,30）;

add（jbt0）;

sta1.setBounds（80,250,200,400）;

add（sta1）;

sta2.setBounds（300,250,300,400）;

add（sta2）;

jbt_result.setBounds（300,200,100,30）;

add（jbt_result）;

this.setVisible（true）;

jta_display.append（"每条边的显示：

\n"）;

jbt1.addActionListener（newActionListener（）{

publicvoidactionPerformed（ActionEvente）{

start0=jtf_start0.getText（）;//初态

Stringstr3=jtf_end0.getText（）;

String[]ss3=newString[100];

ss3=str3.split（","）;//终态在输入的时候以","隔开

for（inti=0;i

Nodenode_end0=newNode（ss3[i]）;

node_end.add（node_end0）;//将终态加入终止结点中

}

}

}）;

jbt0.addActionListener（newActionListener（）{

publicvoidactionPerformed（ActionEvente）{

jta_display.append（jtf_start.getText（）+"—>"+jtf_condition.getText（）

+"—>"+jtf_end.getText（）+"\n"）;

Nodenode_temp=newNode（jtf_start.getText（）,jtf_condition.getText（）,jtf_end.getText（））;

node.add（node_temp）;//加入非终止结点

if（!

condition.contains（jtf_condition.getText（））&&!

jtf_condition.getText（）.equals（"ε"））

condition.add（jtf_condition.getText（））;//加入条件符号

jtf_start.setText（null）;

jtf_condition.setText（null）;

jtf_end.setText（null）;

}

}）;

jbt_result.addActionListener（newActionListener（）{

publicvoidactionPerformed（ActionEvente）{

myNFA_DFA（）;

}

}）;

}

publicvoidmyNFA_DFA（）{

ArrayListflag=newArrayList（）;//标记

//1、找起始结点,计算起始结点的T0=e_closure（start0）;此时T0没有标记,是子集族C中唯一的元素

ArrayListT0=newArrayList（）;

T0=e_closure（start0）;

C.add（T0）;

flag.add（false）;//此时T0没有标记

//2.标记T0；T1=e_closure（move（T0,a））,T2=e_closure（move（T0,b））····,将T1,T2加入C中，但是未标记

flag.set（0,true）;//标记T0

for（inti=0;i

{ArrayListT=newArrayList（）;

ArrayListt1=newArrayList（）;

t1=move（T0,condition.get（i））;

T=e_closure0（t1）;

if（!

C.contains（T））

{

C.add（T）;

flag.add（false）;

}

}

//3.分别标记flag=false的对应的C中的项

while（flag.contains（false））{

intindex=flag.indexOf（false）;

flag.set（index,true）;//标记C的index，即

ArrayListC_temp=newArrayList（）;

C_temp=C.get（index）;

for（inti=0;i

{ArrayListT=newArrayList（）;

ArrayListt1=newArrayList（）;

t1=move（C_temp,condition.get（i））;

T=e_closure0（t1）;

if（!

C.contains（T））

{

C.add（T）;

flag.add（false）;

}

}

}

display（）;//在文本域中显示结果

}

publicvoiddisplay（）{

jta_display1.append（"算法终止共构造了"+C.size（）+"个子集：

\n"）;

for（inti=0;i

{

jta_display1.append（"T"+i+"="+C.get（i）+"\n"）;

CC.add（"T"+i）;//给新得的子集重新命名T1,T2,T3....

}

jta_display1.append（"给定NFA构造的DFA为：

\n"）;

jta_display1.append（"1、S={"）;

for（inti=0;i

jta_display1.append（"["+CC.get（i）+"],"）;

jta_display1.append（"["+CC.get（CC.size（）-1）+"]}\n"）;

jta_display1.append（"2、ε={"）;

for（inti=0;i

jta_display1.append（CC.get（i）+","）;

jta_display1.append（CC.get（CC.size（）-1）+"}\n"）;

ArrayListD=newArrayList（）;

D=transform（C）;

jta_display1.append（"3、\n"）;

for（inti=0;i

jta_display1.append（D.get（i）+"\n"）;

jta_display1.append（"4、S0=["+CC.get（0）+"]\n"）;

jta_display1.append（"5、St=["+CC.get（CC.size（）-1）+"]\n"）;

}

publicArrayListtransform（ArrayList>c）{//转换函数D

ArrayListr=newArrayList（）;

ArrayListr_temp=newArrayList（）;

for（inti=0;i

ArrayListc_temp=newArrayList（）;

c_temp=c.get（i）;

for（intj=0;j

r_temp=e_closure0（move（c_temp,condition.get（j）））;

for（intk=0;k

if（r_temp.equals（C.get（k）））

r.add（"D（["+CC.get（i）+"],"+condition.get（j）+"）=["+CC.get（k）+"]"）;

}

}

}

returnr;

}

publicArrayListe_closure0（ArrayListAA）{

ArrayListT1=newArrayList（）;

for（inti=0;i

{

ArrayListT=newArrayList（）;

T=e_closure（AA.get（i））;

for（intj=0;j

T1.add（T.get（j））;

}

}

returnT1;

}

publicArrayListe_closure（StringA）{

ArrayListT=newArrayList（）;

for（intk=0;k