正规式转换为NFA代码实现

最新推荐文章于 2024-04-25 11:01:41 发布
最新推荐文章于 2024-04-25 11:01:41 发布
阅读量6k 收藏 90
点赞数 10
文章标签： 正则表达式 nfa 编译器 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Carmelo_7/article/details/120708775
版权

问题引入

正规式是一种编译原理课程中经常提到的描述文法的语法规则，与正则表达式有相同之处，但并不是同一个概念。有效的正规式的字母表∑ = { a − z , A − Z } 。

所有的正规式中的符号以及对应的规则如下：

‘*’：表示闭包；
‘|’：表示联合（或）——在有的版本中也用’+'来表示；

‘.’：表示连接（与）；

NFA（non-deterministic finite automaton with ε-move,ε-NFA）带空移动的非确定的有穷状态自动机

从正规式到NFA的转换是编译原理课程中经典的问题，现在考虑使用C++代码来实现这一过程

解题分析

首先我们考虑如何表示NFA，博主这里采用的方法是将NFA的每一条边都显示并且输出出来，例如：边1 起始节点为：A1 转换过程为：a 结束节点为：A2，并以此方式展示NFA的所有的边。这里就需要构造一个结构体结构体Edge（由两个首尾节点和一个转换过程组成，表示NFA中的一条边）

在这里插入图片描述

1、用户输入正规式

2、对正规式进行合法性判断

3、对合法的正规式补全省略的连接符号 ’ . ’

4、将所得的中缀表达式转换为后缀表达式（逆波兰式）

5、“计算”后缀表达式。即将后缀表达式转换为NFA

​ （1）碰到字母表中的字符构造成一个结构体Edge（由两个首尾节点和一个转换过程组成，表示NFA中的一条边），进行压栈

​ （2）碰到运算符，从栈顶弹出一个（单目运算符）或两个字母（双目运算符），并进行对应的操作

函数Unite(Edge Left, Edge Right)，处理 a|b的情况，并返回一个Edge类型

处理方法：新增两个空的节点，四条边**（红色所示）**，并将原有的a、b连起来，如图所示，返回的Edge的变量起始节点为新生成的A5，结束节点为新生成的A6，转换过程Thro置空 ‘ ’

在这里插入图片描述

函数Join(Edge Left, Edge Right)，处理 a.b的情况，并返回一个Edge类型

处理方法：把右边Right的起始节点Begin 改成Left的结束节点End，并返回一个新的Edge的对象，起始节点为Left的开始节点，结束节点为Right的结束节点，转换过程Thro置空 ‘ ’

函数Self(Edge edge) ，处理 a*的情况，并返回一个Edge类型

处理方法：新增两条边**（红色所示）**构成闭环，返回传过来的参数edge，但需要把edge的转换过程变量Thro置空 ‘ ’

在这里插入图片描述

代码实现

RexpToNFA.h

#include <iostream>
#include <cmath>
#include <string>
#include <stack>
#include <queue>
using namespace std;

int Aflag = 0;//a用于标记NFA中的状态，例如：A0、A1

class Edge {
public:
	Edge() {
		this->begin = "";
		this->thro = ' ';
		this->end = "";
	};

	Edge(string begin, char thro, string end) {
		this->begin = begin;
		this->thro = thro;
		this->end = end;
	}

	void setThro(char ch) {
		this->thro = ch;
	}

	char getThro() {
		return this->thro;
	}

	void setBegin(string ch) {
		this->begin = ch;
	}

	string getBegin() {
		return this->begin;
	}

	void setEnd(string ch) {
		this->end = ch;
	}

	string getEnd() {
		return this->end;
	}


private:
	char thro;
	string begin;
	string end;
};

class RTN {
public:
	RTN() {};

	bool isletter(char ch) {
		if (ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z') {
			return true;
		}
		else {
			return false;
		}
	}

	bool islegal(string s) {
		int Lbracket = 0;
		int Rbracket = 0;
		RTN r;
		for (int i = 0; i < s.length(); i++) {
			char ch = s[i];
			if (ch == '*' || ch == '|' || ch == '.') {
				continue;
			}
			//数字不考虑判断
			else if (ch >= 0 && ch <= 9) {
				continue;
			}
			else if (r.isletter(ch)) {
				continue;
			}
			else if (ch == '(') {
				Lbracket++;
			}
			else if (ch == ')') {
				Rbracket++;
			}
			else {
				return false;
			}
		}
		if (Lbracket != Rbracket) {
			return false;
		}
		else {
			return true;
		}
	}

	//将输入的表达式中的连接符号用'.'补全
	string turnToConnect(string s) {
		string ns = s.substr(0, 1);
		for (int i = 1; i < s.length(); i++) {
			char prech = s[i - 1];
			char ch = s[i];
			//连续的字母之间需要添加上连接符号'.'
			if (isletter(prech) && isletter(ch)) {
				ns = ns + '.' + ch;
				//cout << endl << ns;
				continue;
			}
			//判断当前是字母，并且前面是右括号')'的情况
			else if (isletter(ch) && prech == ')') {
				ns = ns + '.' + ch;
				continue;
			}
			//判断当前是左括号'('，并且前面是右括号')'或者前面是字母的情况
			else if (ch == '(' && prech == ')' || ch == '(' && isletter(prech)) {
				ns = ns + '.' + ch;
				continue;
			}
			else {
				ns += ch;
				//cout << endl << ns;
				continue;
			}
		}
		return ns;
	}

	string ReversePolishType(string s) {
		stack<char> st;
		string ns = "";

		for (int i = 0; i < s.length(); i++) {
			char ch = s[i];
			if (isletter(ch)) {
				ns = ns + ch;
			}
			else if (ch == '(') {
				st.push(ch);
			}
			else if (ch == ')') {
				while (st.top() != '(') {
					ns = ns + st.top();
					st.pop();
				}
				st.pop();//将栈顶剩余的左括号弹出
			}
			else if (ch == '*') {
				ns = ns + ch;
				//'*'是单目运算符，碰到的时候直接弹出
				/*if (st.empty() || st.top() == '.' || st.top() == '|' || st.top() == '(') {
					st.push(ch);
				}
				else {
					while (st.top() == '*') {
						ns = ns + st.top();
						st.pop();
						if (st.empty()) break;
					}
					if (st.empty() || st.top() == '.' || st.top() == '|' || st.top() == '(') {
						st.push(ch);
					}
				}*/
			}
			else if (ch == '.') {
				if (st.empty() || st.top() == '|' || st.top() == '(') {
					st.push(ch);
				}
				else {
					while (st.top() == '*' || st.top() == '.') {
						ns = ns + st.top();
						st.pop();
						if (st.empty()) break;
					}
					if (st.empty() || st.top() == '|' || st.top() == '(') {
						st.push(ch);
					}
				}
			}
			else if (ch == '|') {
				if (st.empty() || st.top() == '(') {
					st.push(ch);
				}
				else {
					while (st.top() == '*' || st.top() == '.' || st.top() == '|') {
						ns = ns + st.top();
						st.pop();
						if (st.empty()) break;
					}
					if (st.empty() || st.top() == '(') {
						st.push(ch);
					}
				}
			}
		}
		while (!st.empty()) {
			ns = ns + st.top();
			st.pop();
		}

		return ns;
	}

	//处理 a|b
	Edge Unite(Edge Left, Edge Right) {
		Edge ed1(to_string(Aflag), '#', Left.getBegin());
		Edge ed2(to_string(Aflag), '#', Right.getBegin());
		Edge ed3(Left.getEnd(), '#', to_string(Aflag + 1));
		Edge ed4(Right.getEnd(), '#', to_string(Aflag + 1));
		q.push(ed1);
		q.push(ed2);
		q.push(ed3);
		q.push(ed4);
		if (Left.getThro() != ' ') {
			this->q.push(Left);
		}
		if (Right.getThro() != ' ') {
			this->q.push(Right);
		}

		Edge ed(to_string(Aflag), ' ', to_string(Aflag + 1));
		Aflag = Aflag + 2;
		return ed;
	}

	//处理 a.b
	Edge Join(Edge Left, Edge Right) {
		Right.setBegin(Left.getEnd());
		if (Left.getThro() != ' ') {
			q.push(Left);
		}
		if (Right.getThro() != ' ') {
			q.push(Right);
		}
		
		
		Edge ed(Left.getBegin(), ' ', Right.getEnd());
		//Edge ed(Left.getBegin(), Left.getThro() + '.' + Right.getThro(), Right.getEnd());
		return ed;
	}

	//处理 a*
	Edge Self(Edge edge) {
		Edge ed1(edge.getBegin(), '#', edge.getEnd());
		Edge ed2(edge.getEnd(), '#', edge.getBegin());
		this->q.push(ed1);
		this->q.push(ed2);
		/*Edge ed1(to_string(Aflag), '#', edge.getBegin());
		Edge ed2(edge.getEnd(), '#', to_string(Aflag + 1));
		Edge ed3(edge.getEnd(), '#', edge.getBegin());
		Edge ed4(to_string(Aflag), '#', to_string(Aflag+1));
		this->q.push(ed1);
		this->q.push(ed2);
		this->q.push(ed3);
		this->q.push(ed4);*/

		if (edge.getThro()!=' ') {
			this->q.push(edge);
		}
		
		Aflag = Aflag + 2;
		Edge ed(to_string(Aflag), ' ', to_string(Aflag + 1));
		return ed;
	}

	void PolishTypeToNFA(string s) {
		stack<Edge> st;
		Aflag = 0;//a用于标记NFA中的状态，例如：A0、A1
		for (int i = 0; i < s.length(); i++) {
			char ch = s[i];

			if (this->isletter(ch)) {
				Edge ed(to_string(Aflag), ch, to_string(Aflag + 1));
				Aflag = Aflag + 2;
				st.push(ed);
			}
			else if (ch == '*') {
				Edge ed = st.top();
				st.pop();
				st.push(this->Self(ed));
			}
			else if (ch == '.') {
				Edge ed1 = st.top();
				st.pop();
				Edge ed2 = st.top();
				st.pop();
				Edge ed = Join(ed2, ed1);
				st.push(ed);
			}
			else if (ch == '|') {
				Edge ed1 = st.top();
				st.pop();
				Edge ed2 = st.top();
				st.pop();
				st.push(this->Unite(ed1, ed2));
			}
		}

		while (!this->q.empty())
		{
			Edge e = q.front();
			cout << endl << "开始结点为：" << e.getBegin() << "     转换过程为：" << e.getThro() << "     结束结点为：" << e.getEnd() ;
			q.pop();
		}

	}

private:
	queue<Edge> q;
};

RexpToNFA.cpp

#include <iostream>
#include <cmath>
#include <string>
#include <stack>
#include <queue>
#include "RexpToNFA.h"
using namespace std;
int main() {
	RTN rt;
	cout << "有效的正规式的字母表∑={a-z,A-Z}，辅助字母表∑={'*','|','(',')','.'}" << endl;
	cout << "'*'   表示闭包"<< endl <<"'|'   表示联合" << endl << "'.'   表示连接" << endl;
	while (1) {
		
		cout << "\n请输入一个正规式:";
		string s = "";
		cin >> s;
		if (rt.islegal(s)) {
			cout << "输入的正规式合法！"<<endl;
			string ss = rt.turnToConnect(s);
			cout << "补缺省略的连接符号'.'之后为：" <<ss << endl;
			cout << "对应的后缀表达式（逆波兰式）为：" <<rt.ReversePolishType(ss);
			string rs = rt.ReversePolishType(ss);
			rt.PolishTypeToNFA(rs);
		}
		else {
			cout << "输入的正规式不合法！"<<endl<<"请重新输入：";
		}
	}

}
Carmelo_7
关注
  • 10
    点赞
  • 踩
  • 90
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
编译原理 —— 正规式转换为有穷自动机
starter_____的博客
01-26 3443
要将正则表达式RE转换到DFA比较困难，因此，我们往往先将正则表达式RE转换为NFA，再将NFA转换为DFA 根据RE构造NFA 示例 r=（alb）*abb 从NFA到DFA的转换 DFA的每个状态都是一个由NFA中的状态构成的集合，即NFA状态集合的一个子集 示例（不带ε边的NFA） r=a* a b* b c* c （1）画出NFA图 （2）得到转换表 （3）得到结果 示例...
给定正规式转化为等价的NFA代码实现
theonlytao的博客
12-29 1万+
词法分析程序题 题目 给定正规式，转化为等价的NFA 算法 结构体介绍 state结构体 struct state//定义状态结构体 {          string input;//输入符号集合          vector *next;//输出状态集合,与输入符号集合一一对应 }; input[i]和（*next）[i]一一对应，若next.size()为0则表示到了
正规式与有限自动机一（文法转NFA）
Willy__QI的博客
11-08 5416
正规式转NFA由以下几种基础的情况组成： （1）单个字符 （2）并运算 （3）连接运算 （4）闭包运算 针对非操作符以及各种操作符的详细处理： 　　　1' 当遇到左括号’(‘时：直接压入栈中即可； 　　　2' 当遇到右括号')'时：依次弹出符号栈中的符号直到遇到'('为止。在依次弹出符号栈中的符号时对NFA栈中的NFA元素的操作是：弹出NFA栈顶的两个元素，进行...
编译原理正则表达式转NFA转DFA DFA最小化 Cpp代码
09-17
编译原理课的大作业 包含三个小实验 在一个cpp文件里 正则表达式转换为nfa nfa转换为dfa dfa最小化 个人原创代码
编译原理：从正则表达式到NFA，python实现
最新发布
m0_51434516的博客
04-25 259
编译原理：从正则表达式到NFA
正规式转NFA
weixin_45633417的博客
12-16 1592
#include<iostream> #include<cstring> #include<string> #include<stack> #include<vector> #include<set> #include<queue> #define MAX 128 using namespace std; typedef set<int> IntSet; typedef set<char> Ch
词法分析程序之正规式转换成NFA
热门推荐
程序猿一帆
10-27 2万+
想知道正则表达式背后的原理吗？来瞧瞧吧，这里都有。
正规式转换为有穷自动机
weixin_44769592的博客
05-06 1374
有穷自动机正规式R和有限自动机NFA的转换三个替换规则用三个重要运算构造矩阵画出DFA最小化例题 正规式R和有限自动机NFA的转换 正规文法⇔ 正规式 ⇔ 有限自动机 三个替换规则 用三个重要运算构造矩阵 画出DFA 最小化 例题 构造正规式(a|b)*(aa|bb)(a|b)*的dfa ...
编译原理-代码-正规式转换成NFA
哉的博客
07-05 5263
[点击链接] 正规式转换成NFA 输入：正规式 输出：NFA 算法总流程描述： 思路[跟网上一般做法不一样]： 1.首先设置几个缓冲栈，负责用来在运算的过程当存储器，包括一个存储最后结果的栈。 2.然后设置几个数值，分别存储当前状态数、左括号(、右括号)、星号*的个数。 3.由于代码自己写的过于简陋，所以要求输入必须带严谨的括号（），并且一个（）内最多带两位纯字母，否则输...
用Java做编译原理正规式转换成NFA.rar
07-05
在Java中实现正规式到NFA的转换，需要掌握数据结构（如图和队列）和算法（如深度优先搜索或广度优先搜索）。同时，理解和应用正则表达式理论以及自动机理论是必不可少的。 标签中的"java"表明代码是用Java编程语言...
正规文法转正规式+正规式NFA（完整可运行代码）
09-10
即正规式左部相同的放在一起，本程序使用vector容器实现的对象放置，然后对所有的没有外部依赖的元素进行整合，最后依据没有外部依赖的整合后的表达式对其他的正规文法进行转换，最终得到转换结果。 （2）正规式NFA ...
Thompson转换正规式为NFA.zip
11-02
标题“Thompson转换正规式为NFA.zip”指的是一个压缩包文件，其中包含了将正规式转化为非确定性有限状态自动机（NFA）的相关代码。这个过程是编译原理中的一个重要概念，它允许我们用数学模型来处理正则表达式的匹配...
正规式转换成自动机的图形表示
09-11
编译原理实验作业，包括正规式转NFA，NFA转DFA，以及DFA最小化。 参考了网上很多代码，可能会有些乱，有实验报告，可以按照实验报告截图操作。试了很多表达式，最后转化的都是正确的，当做实验作业已经够用了。
正则表达式转换为nfa以c语言源程序
05-10
代码相对简单； c语言实现； 正则表达式转换为nfa;
正规式转换到非确定有穷自动机转换的一般算法
szr712的博客
11-02 3024
要求 用C++ 实现； input.txt描述正规式，需要编程加以解析，该文件规定的格式为：第一行写处正规式的符号集，规定符号集为0-9共10个数字符，第二行写正规式，如： 0123456789 (0|1)*0.10* （注：*表示闭包运算，.表示连接该符号可省略） output.txt为描述非确定有穷自动机的文件，有程序生成，生成时需按如下格式： 第一行写出状态集，用大写字母A-Z表...
使用C语言实现正规表达式到自动机的转换
qq_44075108的博客
02-14 8379
正规表达式与自动机 编程完成以下功能: (1) 将一个正规表达式转换为 NFA (2) 将一个 NFA 转换为 DFA (3) 对 DFA 进行最小化 (4) 利用 DFA 判断输入的字符串是否为符合词法规则
编译原理 --- 正规式与NFA之间的转换，以及词法分析程序自动生成 --- LEX
qq_51947882的博客
10-11 3013
1.首先针对我们要分析的语言设计一个LEX源程序，并将其输入到LEX编译器中，编译完成后我们就能够得到一个用我们要分析的语言编写而成的词法分析程序，再将这个程序传给我们要分析的语言的编译器转换为机械语言后，就能够得到一个可执行的语法分析程序（.exe）2.l(r)指的是正规是r对应的正规集，而L(M)则是有限自动机能够识别的字的集合，当这二个集合相等的时候我们称正规式r和有限自动机M之间是等价。1.第三条规则中 r2 和 * 是连在一起的，求的是r2这个正规式对应的正规集进行闭包运算后得到的集合。
编译原理——正规式、NFA转换构造DFA、DFA的化简
与其邻渊羡渔，不如退而结网
12-24 2万+
我这里刚开始写的比较繁琐，主要是方便理解，做熟悉的话，可以直接写出不成立条件，从集合里拆分出来即可，没必要把成立的也写一遍；把删除的点的自环传给替代它的点，把2的入边（原来指向2的边，现在指向它的替代，也就是指向1），2的出边（就是由2引出去的边）不用管；第一问，对于图a，和上面一样，先画出状态转换矩阵，对矩阵进行编号，然后画出DFA，然后通过分割法进行化简，然后画出化简后的DFA即可；比如这个图就是NFA，因为0可以通过输入一个字符a到达本身，还可以通过a到达1，这就是在同一状态，有多条出边；
29. Finite State Machine 有限状态机
kaifei的博客
10-20 305
文章目录What is FSMWhy use FSMHow to use What is FSM FSM(Finite State Machine) 有限状态机 Why use FSM FSM 可用来描述有限状态和触发事件以及转换行为的数学模型，只要是满足 FSM 特点的事物，都可以使用统一的数学模型来描述 How to use 有限状态机的特点： 状态有限 离散型 有限状态机构成： State: 状态 Event: 事件 Transition/Action: 执行状态转换的过程 Guard: 检
使用开源库将正规式转换为NFA
05-25
以PCRE为例，可以使用以下代码将正则表达式转换为NFA： ```c++ #include int main() { const char* regex = "a*b"; const char* error; int error_offset; pcre* re = pcre_compile(regex, 0, &error, &...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值