编译原理NFA确定化

1，   实验名称

不确定有穷自动机的确定化。

2，   实验目的

不确定有穷自动机的确定化。

3，   实验原理

 

1.NFA：
一个不确定的有穷自动机M是一个五元组，M=(K,E,f,S,Z)其中
a. K是一个有穷集，它的每个元素称为一个状态；
b. E是一个有穷字母表，它的每个元素称为一个输入符号；
c. f是一个从K×E*到K的子集的映像，即：K*E*->2k，其中2k表示K的幂集；
d. S包含于K，是一个非空初态集；
e. Z包含于K，是一个终态集。
2.DFA：
一个确定的有穷自动机M是一个五元组，M=(K,E,f,S,Z)其中
a. K是一个有穷集，它的每个元素称为一个状态；
b. E是一个有穷字母表，它的每个元素称为一个输入符号；
c. f是转换函数，是K×E->K上的映像，即，如f(ki,a)=kj(ki∈K,kj∈K)就意味着，当前状态为ki，输入字符为a时，将转换到下一状态kj，我们把kj称作ki的一个后继状态；
d. S∈K，是唯一的一个初态；
e. Z包含于K，是一个终态集，终态也称可接受状态或结束状态。

     3，正规式

正规式是一种表示正规集的工具，正规式是描述程序语言单词的表达式，对于字母表∑其上的正规式及其表示的正规集可以递归定义如下。

① ε是一个正规式，它表示集合L(ε)={ε}。

② 若a是∑上的字符，则a是一个正规式，它所表示的正规集L(a)={a}。

③ 若正规式r和s分别表示正规集L(r)、L(s)，则

（a）r|s是正规式，表示集合L(r)∪L(s)；

（b）r·s是正规式，表示集合L(r)L(s)；

（c）r*是正规式，表示集合(L(r))*；

（d）(r)是正规式，表示集合L(r)。

仅由有限次地使用上述三个步骤定义的表达式才是∑上的正规式。

运算符“|”、“·”、“*”分别称为“或”、“连接”和“闭包”。在正规式的书写中，连接运算符“·”可省略。运算符的优先级从高到低顺序排列为：“*”、“·”、“|”。

运算符“|”表示“或”、并集。“*”表示*之前括号里的内容出现0次或多次。

若两个正规式表示的正规集相同，则认为二者等价。两个等价的正规集U和V记作U=V。

4.   实验思路

1.状态集合I的空闭包closure（I），定义为一个状态集。

  算法：

遍历I集合中的每一个元素，对于每一元素遍历所有的边，若该元素在NFA中连接到空边，则获取空边另一端的元素，判断元素是否在I中，若不在I中，则加入I，直到遍历结束。

2.确定化

算法：

A．找到NFA的开始符S，对开始符求closure（S），并创建集合T

并T（0）=closure（{S}）

B．找到T中未被标记的集合T1，若未找到，

C．对T1中，每一元素，执行函数F

D．执行步骤B

函数F：

A．对于T1中的每一元素a，找到每一元素在NFA同一类型的边所对应的元素c，把所有的c都放在集合C中，对于C求C=closure（C）。判断C是否在T中，若不在，则把C加入T。，记录T1->C的边，

B．执行A，知道把所有不同类型的边遍历为止。

3.构造DFA

a.对于集合In，选出集合In的每一I，在I中选出一个元素代表该集合，构造新的DFA

5.   实验小结

  实验算法清晰，简单，只要是对于每一集合反复求closure闭包比较麻烦。程序循环，判断，标志位特别多。很容易出错。对于程序的内存管理更要小心，不要内存越界。

同时，我用的code blocks 编译器问题很大。当程序代码超过一定量、内存分配的数目和空间比较多的时候，对于内存的管理就会出现难以预料的错误。比如在程序开头分配了一段内存，在程序的末尾要使用该内存给其他变量赋值时，就会导致程序崩溃

#include<stdio.h>#include<malloc.h>#include<string.h>char nfa[25][4];    struct list    {        char a[20];         int  b;         char c;         int a_n;    } ;    struct list t[20];    int n; /*number of NFA edage*/int main(){    printf("鉏飞祥E21414018\n");    int cg=3;    printf("请输入每条边和节点\n例如：1a8表示0从1边到8，*代表空边以/结束输出\n");    void closure(int n);    char u[20];    int  ed[20][4];    int n_ed=0;    n=0;    int n_t=0;/*number of T */    int i=0;    int k=1;    int j;    while(1)    {        scanf("%s",nfa[i]);        if(nfa[i][0]=='/')            break;        i++;         n++;    }    t[0].a[0]=nfa[0][0];    for(i=0;i<n;i++)    {        if(nfa[i][0]==nfa[0][0])        {            if(nfa[i][1]=='*')            {                t[0].a[k]=nfa[i][2];                k++;            }        }    }    t[0].a_n=k;    t[0].a[k]='\0';    n_t++;    t[0].b=0;    closure(0);    char temp;    for(i=0;i<n_t;i++)        for(j=0;;j++)        {            if(t[i].a[j]=='\0')                break;        for(k=j+1;;k++)    {        if(t[i].a[k]=='\0')            break;        if(t[i].a[k]<t[i].a[j])        {            temp=t[i].a[k];            t[i].a[k]=t[i].a[j];            t[i].a[j]=temp;        }    }        }    int u_i;    int nn=n_t;    while(1)    {        u_i=0;        int bo=0;        int t_i;        for(t_i=0;t_i<n_t;t_i++)/*judge over*/        {            if(t[t_i].b==0)            {                t[t_i].b=1;                bo++;                break;            }        }        if(bo==0)            break;        char a='a';           int cc=cg; /*有几条不同的边*/        while(cc--)        {            u_i=0;        for(i=0;i<t[t_i].a_n;i++)        {            for(j=0;j<n;j++)            {                if(t[t_i].a[i]==nfa[j][0])                    if(nfa[j][1]==a)                {                int b1=0;                int ii;                for(ii=0;ii<u_i;ii++)                {                    if(u[ii]==nfa[j][2])                        b1=1;                }                if(b1==0)                    u[u_i]=nfa[j][2];                    u_i++;                }            }        }        u[u_i]='\0';        int i,j,k;    for(i=0;i<u_i;i++)        for(j=0;j<n;j++)        {            if(u[i]==nfa[j][0])                if(nfa[j][1]=='*')            {                int b1=0;                int ii;                for(ii=0;ii<u_i;ii++)                {                    if(u[ii]==nfa[j][2])                        b1=1;                }                if(b1==0)                {                u[u_i]=nfa[j][2];                u_i++;                }            }        }        u[u_i]='\0';        char temp;        for(i=0;i<u_i;i++)            for(j=i+1;j<u_i;j++)        {            if(u[j]<u[i])            {                temp=u[j];                u[j]=u[i];                u[i]=temp;            }        }        bo=0;        for(i=0;i<n_t;i++)        {            if(strcmp(u,t[i].a)==0)            {                bo++;                 ed[n_ed][0]=nn-1;            ed[n_ed][1]=(int)a;            ed[n_ed][2]=i;            n_ed++;                break;            }        }        if(bo==0)            if(u_i!=0)        {            strcpy(t[n_t].a,u);            t[n_t].b=0;            t[n_t].a_n=u_i;            ed[n_ed][0]=nn-1;            ed[n_ed][1]=(int)a;            ed[n_ed][2]=n_t;            n_ed++;            n_t++;        }        a++;        }         nn++;    }    for(i=0;i<n_t;i++){            t[i].c=t[i].a[i];            printf("用 %c  代表 %s\n",t[i].c,t[i].a);    }        for(i=0;i<n_ed;i++)        {            printf("%c-%c-%c\n",t[ed[i][0]].c,ed[i][1],t[ed[i][2]].c);        }}void closure(int nn){    int i,j,k;    int ii,jj;    for(i=0;i<t[nn].a_n;i++)        for(j=0;j<n;j++)        {            if(t[nn].a[i]==nfa[j][0])                if(nfa[j][1]=='*')            {                int b=0;                for(ii=0;ii<t[nn].a_n;ii++)                {                    if(t[nn].a[ii]==nfa[j][2])                        b=1;                }                if(b==0)                {                t[nn].a[t[nn].a_n]=nfa[j][2];                t[nn].a_n++;                }            }        }        t[nn].a[t[nn].a_n]='\0';}