【编译原理】正则表达式转NFA

最新推荐文章于 2023-01-19 14:13:54 发布
最新推荐文章于 2023-01-19 14:13:54 发布
阅读量6.3k 收藏 99
点赞数 14
分类专栏： 编译原理 文章标签： 正则表达式 非确定性有穷自动机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43417265/article/details/104441707
版权

第一步：读入正则表达式

从txt文件中读入正则表达式

#include <iostream>
#include <fstream>
#include <string>
#include <cstring>
#include <algorithm>
#define MAX_TOKEN 100
using namespace std;

//词
struct Token
{
    string name;//词的名字
    string regExp;//正则表达式
    vector<int>finalState;//终态
};

int readTXT(string fileName,vector<Token>&tokens)
{
    ifstream input(fileName);
    if(!input)
    {
        cout<<"Failed"<<endl;
        return -1;
    }

    //读取正则表达式
    string line;//读入的每一行
    while(getline(input,line))
    {
        int i;
        Token temp;
        for(i=0;line[i]!=':'&&i<line.size();i++)
        {
            temp.name+=line[i];//获取词的名字
        }
        temp.regExp=line.substr(i+1,line.size()-i);//获取词的正则表达式
        tokens.push_back(temp);
    }
    input.close();
    return 0;
}

 

第二步：处理正则表达式

把使用连接运算的地方换成“.”（符号可自定义），然后将中缀正则表达式转成后缀表达式。

#include <iostream>
#include <fstream>
#include <string>
#include <stack>
#include <stdlib.h>
#include <algorithm>
using namespace std;

//把两字符之间的连接加上.
string add_symbol(string reg)
{
    int l=reg.size();
    string regE=reg;
    int j=0;//加的.的数量
    for(int i=0;i<l-1;i++)
    {
        //a.b
        if(reg[i]!='('&&reg[i]!='|'&&isalnum(reg[i+1]))
        {
            regE.insert(i+j+1,".");
            j++;
        }
        //a.( )
        else if(reg[i+1]=='('&&reg[i]!='|'&&reg[i]!='(')
        {
            regE.insert(i+j+1,".");
            j++;
        }
    }
    return regE;
}

//运算符优先级表
char *priorities[]=
{
//   #|.*()
    "E<<<<X",
    ">><<<>",
    ">>><<>",
    ">>>><>",
    "x<<<<=",
    "xxxxxx",
};

//运算符编号
int getNum(char c)
{
    switch(c)
    {
        case '#':return 0;
        case '|':return 1;
        case '.':return 2;
        case '*':return 3;
        case '(':return 4;
        case ')':return 5;
    }
}
//中缀转后缀
string convert(string reg)
{
    string post="";
    stack<char>op;
    op.push('#');

    for(int i=0;i<reg.size();i++)
    {
        if(isalnum(reg[i]))
        {
            post+=reg[i];
        }
        //运算符处理
        else
        {
            switch(reg[i])
            {
            case '(':
                op.push(reg[i]);
                break;
            case ')':

                //将栈顶运算符弹出并输出，直到遇到左括号
                while(!op.empty()&&op.top()!='(')
                {
                    post+=op.top();
                    op.pop();
                }
                op.pop();//弹出左括号，不输出
                break;
            default:
                //优先级大于栈顶优先级
                if(op.top()=='('||(op.top()!='('&&priorities[getNum(op.top())][getNum(reg[i])]=='<'))
                {
                    op.push(reg[i]);
                }
                //优先级小于栈顶优先级
                else
                {
                    while(priorities[getNum(op.top())][getNum(reg[i])]=='>')
                    {
                        post+=op.top();
                        op.pop();
                    }
                    op.push(reg[i]);
                }
                break;
            }
        }
    }

    while(!op.empty())
    {
        post+=op.top();
        op.pop();
    }
    post.pop_back();//去掉'#'
    return post;
}

 

第三步：正则表达式转NFA

  1. 遇到字母，构建基本NFA（我这里用cell数据结构表示），入栈
  2. 遇到运算符，出栈相应数量的NFA（如：| 作为双目运算符，就要出栈两个NFA），然后构建对应的NFA，入栈
#include <iostream>
#include <fstream>
#include <string>
#include <stack>
#include <stdlib.h>
#include <algorithm>
#define MAX 5000
using namespace std;

/*注意状态总数量和状态编号是不同的，因为状态总数可能减少(连接运算),但编号是一直增下去的*/
int state_count=0;//状态的总数量
int nmbState=1;//状态编号
int nullSymbol=0;//输入字符为?的边的数量

struct state
{
    int id;
};
struct Edge
{
    state source;
    state target;
    char symbol;//输入字符
};
//单个NFA单元
struct cell
{
    state start;
    state end;
    int count;//边的数量
    Edge edges[MAX];
};
//合并后正则的NFA
struct bigCell
{
    state start;
    vector<state>end;
    int count;
    Edge edges[MAX];
};
//单个字符NFA
cell makeNFA(char c)
{
    cell a;
    a.count=0;
    state s,t;
    s.id=nmbState++;
    t.id=nmbState++;

    state_count+=2;

    //构建边
    Edge e;
    e.source=s;
    e.target=t;
    e.symbol=c;

    //构建基本NFA
    a.edges[a.count++]=e;
    a.start=s;
    a.end=t;

    return a;
}
//把s中的边复制到t中
int edgesCopy(cell s,cell &t)
{
    for(int i=0;i<s.count;i++)
    {
        t.edges[t.count++]=s.edges[i];
    }
}
//把s中的边复制到t中
int edgesCopy(cell s,bigCell &t)
{
    for(int i=0;i<s.count;i++)
    {
        t.edges[t.count++]=s.edges[i];
    }
}
//或运算NFA
cell orNFA(cell left,cell right)
{
    cell newCell;
    newCell.count=0;

    //新增两个状态
    state s,t;
    s.id=nmbState++;
    t.id=nmbState++;

    state_count+=2;

    newCell.start=s;
    newCell.end=t;
    //cout<<"|"<<t.id<<endl;

    //新增四条边
    Edge e1,e2,e3,e4;

    //连接初始状态的两条
    e1.source=s;
    e1.symbol='?';
    e1.target=left.edges[0].source;
    e2.source=s;
    e2.symbol='?';
    e2.target=right.edges[0].source;

    //连接结束状态的两条
    e3.source=left.edges[left.count-1].target;
    e3.symbol='?';
    e3.target=t;
    e4.source=right.edges[right.count-1].target;
    e4.symbol='?';
    e4.target=t;

    nullSymbol+=4;

    //构建边
    edgesCopy(left,newCell);
    edgesCopy(right,newCell);
    newCell.edges[newCell.count++]=e1;
    newCell.edges[newCell.count++]=e2;
    newCell.edges[newCell.count++]=e3;
    newCell.edges[newCell.count++]=e4;

    return newCell;
}
//连接运算NFA
cell andNFA(cell left,cell right)
{
    for(int i=0;i<right.count;i++)
    {
        //初始状态合并
        if(right.start.id==right.edges[i].source.id)
        {
            right.edges[i].source.id=left.end.id;
            state_count--;
        }
        //改变结束状态是right的开始状态的边
        else if(right.start.id==right.edges[i].target.id)
        {
            right.edges[i].target.id=left.end.id;
            state_count--;
        }
    }
    right.start.id=left.end.id;
    edgesCopy(right,left);
    left.end.id=right.end.id;
    return left;
}
//星闭包运算NFA
cell starNFA(cell a)
{
    cell newCell;
    newCell.count=0;

    //新增两个状态
    state s,t;
    s.id=nmbState++;
    t.id=nmbState++;

    state_count+=2;

    newCell.start=s;
    newCell.end=t;
    //cout<<"*"<<t.id<<endl;

    //新增四条边
    Edge e1,e2,e3,e4;

    //空边
    e1.source=s;
    e1.symbol='?';
    e1.target=t;
    //循环边
    e2.source=a.end;
    e2.symbol='?';
    e2.target=a.start;
    //起始边
    e3.source=s;
    e3.symbol='?';
    e3.target=a.start;
    //终止边
    e4.source=a.end;
    e4.symbol='?';
    e4.target=t;

    nullSymbol+=4;

    //构建NFA
    edgesCopy(a,newCell);
    newCell.edges[newCell.count++]=e1;
    newCell.edges[newCell.count++]=e2;
    newCell.edges[newCell.count++]=e3;
    newCell.edges[newCell.count++]=e4;

    return newCell;
}
cell reg2NFA(string reg)
{
    stack<cell>s;//基本NFA栈
    cell current,left,right;
    for(int i=0;i<reg.size();i++)
    {
        switch(reg[i])
        {
        case '|':
            //弹出两个NFA
            right=s.top();
            s.pop();
            left=s.top();
            s.pop();
            //用弹出的NFA构建新NFA，入栈
            current=orNFA(left,right);
            s.push(current);
            break;

        case '.':
            right=s.top();
            s.pop();
            left=s.top();
            s.pop();
            current=andNFA(left,right);
            s.push(current);
            break;

        case '*':
            left=s.top();
            s.pop();
            current=starNFA(left);
            s.push(current);
            break;

        //数字或字母
        default:
            current=makeNFA(reg[i]);//构建基本NFA
            s.push(current);//入栈
        }
    }
    current=s.top();
    s.pop();
    return current;
}

int showNFA(cell c)
{
    cout<<"NFA信息:"<<endl;
    cout<<"初态:"<<c.start.id<<endl;
    cout<<"终态:"<<c.end.id<<endl;
    for(int i=0;i<c.count;i++)
    {
        cout<<c.edges[i].source.id<<" "<<c.edges[i].symbol
        <<" "<<c.edges[i].target.id<<endl;
    }
    cout<<endl;
    return 0;
}
int showNFA(bigCell c)
{
    cout<<"NFA信息:"<<endl;
    cout<<"初态:"<<c.start.id<<endl;
    cout<<"终态:";
    for(int i=0;i<c.end.size();i++)
        cout<<c.end[i].id<<" ";
    cout<<endl;
    for(int i=0;i<c.count;i++)
    {
        cout<<c.edges[i].source.id<<" "<<c.edges[i].symbol
        <<" "<<c.edges[i].target.id<<endl;
    }
    cout<<endl;
    return 0;
}

 

第四步：合并NFA（选做）

因为最后要构建词法分析器，所以做成一个大的NFA后期识别会比较方便，因此可选择将每个正则表达式的NFA合并为一个大的。

具体方法是把新增一个状态0，把所有NFA的起点连起来。

//将各个正则表达式的NFA合并
bigCell mergeNFA(vector<cell>nfa)
{
    bigCell NFA;
    NFA.start.id=0;
    NFA.count=0;
    for(int i=0;i<nfa.size();i++)
    {
        NFA.end.push_back(nfa[i].end);

        //连接新起点和旧起点
        Edge e;
        e.source=NFA.start;
        e.symbol='?';
        e.target=nfa[i].start;

        nullSymbol+=1;

        edgesCopy(nfa[i],NFA);
        NFA.edges[NFA.count++]=e;
    }
    return NFA;
}

测试结果

输入：数字、字母及自定义id的正则表达式
在这里插入图片描述
输出：每一条边的 起点 输入字符(’?’ 代表空) 终点
在这里插入图片描述

倒过来是圈圈
关注
  • 14
    点赞
  • 踩
  • 99
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
正则表达式转换为NFA程序代码
01-25
【问题描述】： 输入一个正则表达式，然后将此正则表达式转换为NFA，最后将此NFA输出 【实验要求】： 写出程序运行环境, 体会，程序结构，程序清单， 典型结果，以及结果分析 【程序运行环境】： 此程序是在Visual C++下，新建一个C++ sourse file，然后编译通过
正则表达式转化为NFA
05-18
正则表达式转化为NFA
正则表达式转NFA实现
10-21
正则表达式
正则表达式转换成NFA
liuhai200913的博客
03-26 8133
正则表达式转换成NFA的实现NFA转换图正则表达式转换NFA的算法正则式转换算法的代码 NFA 正则表达式解析的转换规则一般有两种方式，NFA(Nondeterministic Finite Automata 不确定的有穷自动机) 和***DFA(Deterministic Finite Automata 确定的有穷自动机)***。 一个NFA由以下几部分组成: 一个有穷的状态集合S 一个输入符号集合E 一个转换函数,它为每一个状态和输入符号集{E}∪{空字符串ε}都给出了对应的后继状态 S中的一个状态S
正则表达式DFA构造方法
热门推荐
么刚的专栏
09-19 2万+
陈梓瀚 [email protected] http://www.cppblog.com/vczh/1、问题概述随着计算机语言的结构越来越复杂，为了开发优秀的编译器，人们已经渐渐感到将词法分析独立出来做研究的重要性。不过词法分析器的作用却不限于此。回想一下我们的老师刚刚开始向我们讲述程序设计的时候，总是会出一道题目：给出一个填入了四则运算式子的字符串，写程序计算该式子的结果。除此之外，我们有时候
编译原理: Thompson 构造法（正则表达式 转 NFA）
超悠閒的博客
11-26 1万+
编译原理: Thompson 构造法（正则表达式 转 NFA） 文章目录编译原理: Thompson 构造法（正则表达式 转 NFA）简介参考正文什么是状态机有限状态机 FANFA vs DFAThompson 构造法基本单元：单个字符三种转换规则：并 |、连接 ⋂\bigcap⋂、闭包 *示例a(b∣c)∗a(b|c)^{*}a(b∣c)∗(a∣b)∗abb(a|b)^{*}abb(a∣b)∗abb结语 简介 编译过程往往依赖于有限状态机的构建，其中最具代表性的就是正则表达式(Regular Expres
正则表达式转NFA
懒猫的脚印
09-11 1万+
正则表达式的基本运算 正则表达式有三种基本的运算: 连接(Concatenation), 例如 abc, 由a, b, c组成 联合(Union), 例如 a|b|c, 表示a或者b或者c Kleene闭包(Kleene *), 例如 (ab)*, 表示ab串不出现，或者出现1次或一次以上 其它的运算如+, {}等都可以用以上三种基本运算或者运算的组合来表示。 正则表达式转换成NFA ...
从正则表达式到NFA
ID314846818的博客
01-19 3959
我们根据 Thompson 构造法，分步骤构造一下 a(b|c)* 这个正则表达式的转化过程
[编译原理随记]正则表达式转为NFA状态图(Thompsion构造法)
qq_28033719的博客
07-02 6991
上级文章 [编译原理随记]正则表达式记号和状态图：https://blog.csdn.net/qq_28033719/article/details/107067798 [编译原理随记]NFA转DFA子集构造算法：https://blog.csdn.net/qq_28033719/article/details/107068996 准备知识 语法制导： 解析（parse）输入的字符串时，在特定位置执行指定的动作。 语法制导算法： 其实就本文内容，解析字符串是什么状态（像>=通常弄个状态图
编译原理-正则式转化为NFA代码
MARS116048的博客
04-06 1642
实验要求： (1)程序接受文本文件中输入的正则表达式，生成该正则表达式对应的NFA，在屏幕上显示出这个NFA。 (2)统计并输出该NFA中的节点个数和边的个数； (3)输入的正则表达式中包含的运算符包括：连接运算符”.”,闭包运算符“*”,逻辑或运算符“|”,左括号“(“,右括号“)”。 (4)输入的正则表达式中的字符限于大写英文字母，小写英文字母，数字0~9； (5)NFA使用图的邻接链表或者邻...
正则式转NFA,DFA,MFA.zip
07-12
C++实现正则表达式转NFA->DFA->MFA控制台输出并形成文件、画图，画图所选第三方库为Graphviz，文件中已包含，运行前请先阅读文件中的README.txt，压缩包中包含视频演示。集成平台：VS 2017,点击sln文件可以直接运行
正则表达式转换为NFA（Regex to NFA）.jar
05-17
用JAVA写的一个将正则表达式转换为NFA的代码，基于Thompson算法的思想，递归构建NFA。jar为源码文件。 输出非确定有限自动状态机的有向图。如正则表达式: c(a|b)NFA为：0-c->1-ep->2-a->3-ep->7 ,0-c->1-ep->4-b->5-ep->7.其中 ep 表示 epsilon
编译原理正则表达式转NFA转DFA DFA最小化 Cpp代码
09-17
编译原理课的大作业 包含三个小实验 在一个cpp文件里 正则表达式转换为nfa nfa转换为dfa dfa最小化 个人原创代码
编译原理中正规式转化为nfa
05-11
编译原理中的正规式到nfa的转换 超详细的课程设计
基于QT(C++)实现正则表达式转NFA转DFA【100012462】
05-25
语言： c++ 11 IDE：qt creator、 CLion ...编译该项目，必须本地已经下载安装GraphViz,并且需要修改lex.h中的dot常量为你的系统中dot命令的位置。如果是mac系统，你可以通过 which dot 查看具体位置。
【编译原理】LL(1)分析方法 生成语法树（c++实现）
qq_43417265的博客
04-04 1万+
基本流程 输入文法->消除左递归->提取左公共因子->求FIRST集->求FOLLOW集->LL(1)分析表->表驱动的预测语法分析过程->输出语法分析结果和语法树
【编译原理】LR(0)分析方法（c++实现）
qq_43417265的博客
04-27 9867
基本流程 输入文法->拓广文法->求项目集规范族->GO[I,a]转移函数->构造DFA（识别活前缀的自动机->LR(0)分析表->LR(0)分析输入串 代码 c++实现
【编译原理】SLR(1)分析方法（c++实现）
qq_43417265的博客
05-21 7633
基本流程 Created with Raphaël 2.2.0输入文法拓广文法构造DFA（识别活前缀的自动机）SLR(1)分析表SLR(1)分析输入串 当然也要求非终极符号的FIRST和FOLLOW集，这个步骤在构建分析表之前做就好，没什么固定顺序   代码 测试结果 ...
编译原理 正则表达式 转 nfa
最新发布
11-24
编译原理中的正则表达式转换为NFA（非确定有限状态自动机）是一个重要的步骤。在这个过程中，首先我们需要理解正则表达式的语法规则和语义含义。 正则表达式是一种用于描述字符序列的模式的表示方法。它由一系列字符和操作符构成，这些操作符可以表示字符的集合、重复等。例如，字符"a"表示一个字符"a"，字符集[a-z]表示从"a"到"z"的任意字符。 转换正则表达式为NFA的方法是通过递归的方式对正则表达式进行解析和转换。具体步骤如下： 1. 将正则表达式的字符和操作符进行分组。 2. 对分组后的字符和操作符进行处理，生成对应的NFA片段。 3. 根据操作符的优先级，将NFA片段进行合并和连接。 4. 最后得到一个完整的NFA。 在处理正则表达式的过程中，需要考虑到操作符的优先级，例如，使用括号来指定操作符的优先级。同时，还需考虑到正则表达式中可能存在的特殊字符，比如*、+和|等。 通过正则表达式转换为NFA，可以实现对字符串的匹配和识别。NFA可以支持更加复杂的模式匹配需求，并且具有较高的灵活性和效率。 总的来说，将正则表达式转换为NFA是编译原理中的一个重要步骤。它需要理解正则表达式的语法和语义，并通过递归和合并方式生成对应的NFA片段。通过这一过程，可以实现对字符串的高效匹配和识别。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值