C# 正规式转NFA

最新推荐文章于 2023-12-04 21:43:29 发布
最新推荐文章于 2023-12-04 21:43:29 发布
阅读量1k 收藏 24
点赞数 4
文章标签： c# 编译原理 NFA 正规式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43919249/article/details/116277785
版权

正规式转NFA

1、正规式和NFA

  定义（参考编译原理教材）

2、转换思想

  1.使用一个首尾栈来存储表达式首尾节点组的集。

  2.使用一个边栈来存储边的集。

  3.利用后缀表达式，利用首尾栈对表达式做运算并将生成的边加入边栈。

3、转换步骤

 接下来以正规表达式a*b(b|a)*构造与之等价的ε-NFA来演示
（1）转换规则
 <1>基础

在这里插入图片描述

 <2> 归纳

在这里插入图片描述

（2）转成后缀表达式
          a*b.ba|*.
（3）运算
（1）遇到“a”

在这里插入图片描述

 （2）遇到“*”

在这里插入图片描述

 （3）遇到“b”

在这里插入图片描述

 （4）遇到“.”

在这里插入图片描述

 （5）遇到“b”

在这里插入图片描述

 （6）遇到“a”

在这里插入图片描述

 （7）遇到“|”

在这里插入图片描述

 （8）遇到“*”

在这里插入图片描述

 （9）遇到“.”

在这里插入图片描述

 （10）程序执行完毕，首尾中的唯一首尾组即NFA的开始状态和终结状态；边栈中的边集合即NFA。

 结果展示：

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

  C# 代码：
  链接：https://pan.baidu.com/s/1kdKZoOD4OyWs-8Wuxn6uJw 
  提取码：p57w 

//Forms1.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace practice__2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void dFAToolStripMenuItem_Click(object sender, EventArgs e)
        {
            NFA_DFA_MFA f = new NFA_DFA_MFA();
            f.ShowDialog();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }
    }
}


//Forms2.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Text.RegularExpressions;
using System.Collections;

namespace practice__2
{
    public partial class NFA_DFA_MFA : Form
    {
        public NFA_DFA_MFA()
        {
            InitializeComponent();
        }
        
        private void Form2_Load(object sender, EventArgs e)
        {

        }

        private void label1_Click(object sender, EventArgs e)
        {

        }

        private void groupBox1_Enter(object sender, EventArgs e)
        {
           
        }

        private void listView1_SelectedIndexChanged(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {

			Regex r = new Regex("[\\(|\\)|\\*|\\||[a-z]|\\d#949]+");
            string a= textBox1.Text;
			bool t = r.IsMatch(a);
            if (t == false)
            {
                MessageBox.Show("表达式错误", "提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
                MessageBox.Show("正确", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
	
		private String addConnect(String s)
		{ // 为表达式加上连接符
			Stack stack = new Stack();
			char[] chr = s.ToCharArray();
			int point = 0;
			Console.WriteLine(s);
			Console.WriteLine("ZZ");
			Console.WriteLine(chr.Length);
			//a*b(b|a)*
			//a*.b.(b|a)*
			//a*b.ba|*.
			while (point != chr.Length)
			{
			
				Regex r = new Regex("[\\(|\\)|\\*|\\||[a-z]]+");
				Regex r1 = new Regex("[a-z]");
				

				// 对*[a-z]的情况在中间加上连接符后入栈
				if (chr[point] == '*' && point != chr.Length - 1
				&& r1.IsMatch(chr[point + 1] + ""))
				{
					stack.push(chr[point]);
					stack.push('.');
				}
				else if (chr[point] == '(' && point != 0 && chr[point - 1] != '|')
				{
					// 对)(、*(、[a-z](的情况在中间加上连接符后入栈
					stack.push('.');
					stack.push('(');
				}
				else if (point != 0 && r1.IsMatch(chr[point] + "")
			  && (r1.IsMatch(chr[point - 1] + "") || chr[point - 1] == ')'))
				{
					stack.push('.');
					stack.push(chr[point]);
				}
				else
				{
					stack.push(chr[point]);
					Console.WriteLine("ttt");
				}
				point++;
			}
			Console.WriteLine(stack.getString());
			return stack.getString();
		}

		private String change(String s)
		{ // 生成后缀表达式
			char[] chr = s.ToCharArray();
			int point = 0;
			Stack stack = new Stack();
			String str = "";

			while (point != chr.Length)
			{
				switch (chr[point])
				{
					case '(':
						stack.push(chr[point]);
						point++;
						break;
					case ')':
						while (stack.peek() != '(' && !stack.isEmpty())
						{
							str += stack.pop();
						}
						if (!stack.isEmpty() && stack.peek() == '(')
							stack.pop();
						point++;
						break;
					case '*':
						str += chr[point];
						point++;
						break;
					case '|':
					case '.':
						while (!stack.isEmpty() && stack.peek() != '('
						&& stack.peek() != ')'
						&& !compare(chr[point], stack.peek()))
						{
							str += stack.pop();
						}
						stack.push(chr[point]);
						point++;
						break;
					default:
						str += chr[point];
						point++;
						break;
				}
			}
			while (!stack.isEmpty())
			{
				if (stack.peek() == ')' || stack.peek() == ')')
					return "";
				else
					str += stack.pop();
			}
			Console.WriteLine(str);
			return str;

		}

		private bool compare(char a, char b)
		{ //比较操作符的优先级
			if (a == b)
				return false;
			if (a == '*')
				return true;
			if (a == '.')
			{
				if (b == '*')
					return false;
				else
					return true;
			}
			return false;
		}

		private bool check(String str)
		{ // 对后缀表达式做消除运算
			Stack stack = new Stack();
			Stack result = new Stack();
			char[] chr = str.ToCharArray();
			Regex r1 = new Regex("[a-z]");
			for (int i = chr.Length - 1; i >= 0; i--)
				stack.push(chr[i]);
			while (!stack.isEmpty())
			{
				switch (stack.peek())
				{
					case '*':
						if (!r1.IsMatch(result.peek() + ""))
							return false;
						stack.pop();
						break;
					case '.':
					case '|':
						if (result.length() < 2 || !r1.IsMatch(result.pop() + "")
								|| !r1.IsMatch(result.peek() + ""))
							return false;
						stack.pop();
						break;
					default:
						result.push(stack.peek());
						stack.pop();
						break;
				}
			}
			return result.length() == 1 && r1.IsMatch(result.peek() + "");

		}


		int x = 1;
		Stack<int[]> list = new Stack<int[]>();
		Stack<string[]> res = new Stack<string[]>();
		Stack<string[]> res_T = new Stack<string[]>();

		private int getFacoter()
		{
			int s = x;
			x++;
			return s;
		}
		public int[] getElement(Stack<int[]> stack, int position)
		{
			int[] result = stack.Pop();
			if (stack.Count == position)
			{			
				return result;
			}
			else
			{
				int[] element = getElement(stack, position);
				stack.Push(element);
				return element;
			}
		}

		public int[] getfactor()
		{
			return getElement(list, 0);
		}

		public Stack<String[]> getlist()
		{
			return res;
		}
		
		public void ToNFA(String str)
		{
			// TODO Auto-generated constructor stub
			char[] chr = str.ToCharArray();
			for(int i=0;i<chr.Length;i++)		
			{
				char ch = chr[i];
				int[] a = new int[2];
				int[] b = new int[2];
				int[] c = new int[2];
				switch (ch)
				{
					case '.':
						String[] st = new String[3];
						// 取出list中上面的两个关系
						a = list.Peek();
						Console.WriteLine(a);
						list.Pop();
						b = list.Peek();
						Console.WriteLine(b);
						list.Pop();
						// 创建新的关系
						c = new int[2];
						c[0] = b[0];
						c[1] = a[1];
						// 将上面的两个关系替换成新的关系
						list.Push(c);
						// 添加新的NFA项
						st[0] = b[1] + "";
						st[1] = "#";
						st[2] = a[0] + "";
						res.Push(st);
						break;
					case '|':
						c[0] = getFacoter();
						c[1] = getFacoter();
						a = list.Peek();
						list.Pop();
						b = list.Peek();
						list.Pop();
						list.Push(c);
						String[] st1 = new String[3];
						String[] st2 = new String[3];
						String[] st3 = new String[3];
						String[] st4 = new String[3];
						st1[0] = c[0] + "";
						st1[1] = "#";
						st1[2] = a[0] + "";
						res.Push(st1);
						st2[0] = c[0] + "";
						st2[1] = "#";
						st2[2] = b[0] + "";
						res.Push(st2);
						st3[0] = a[1] + "";
						st3[1] = "#";
						st3[2] = c[1] + "";
						res.Push(st3);
						st4[0] = b[1] + "";
						st4[1] = "#";
						st4[2] = c[1] + "";
						res.Push(st4);
						break;
					case '*':
						String[] st5 = new String[3];
						String[] st6 = new String[3];
						String[] st7 = new String[3];
						String[] st8 = new String[3];
						c[0] = getFacoter();
						c[1] = getFacoter();
						a = list.Peek();
						list.Pop();
						list.Push(c);
						st5[0] = c[0] + "";
						st5[1] = "#";
						st5[2] = c[1] + "";
						res.Push(st5);
						st6[0] = c[0] + "";
						st6[1] = "#";
						st6[2] = a[0] + "";
						res.Push(st6);
						st7[0] = a[1] + "";
						st7[1] = "#";
						st7[2] = a[0] + "";
						res.Push(st7);
						st8[0] = a[1] + "";
						st8[1] = "#";
						st8[2] = c[1] + "";
						res.Push(st8);
						break;
					default:
						String[] st9 = new String[3];
						c[0] = getFacoter();
						c[1] = getFacoter();
						list.Push(c);
						st9[0] = c[0] + "";
						st9[1] = ch + "";
						st9[2] = c[1] + "";
						res.Push(st9);
						break;
				}
			}
		}

		private void button4_Click(object sender, EventArgs e)
		{

			Console.WriteLine("AAA");
			string st = textBox1.Text;
			string ss = addConnect(st);
			Console.WriteLine(ss);
			string ss1 = change(ss);
			string ss2;
			if (check(ss1))
			{
				ss2 = ss1;
			}
			else
			{
				ss2 = "";
			}
			//a*b(b|a)*
			//a*b.ba|*.
			Console.WriteLine("BBB");
			Console.WriteLine(ss2);
			Console.WriteLine("CCC");

			ToNFA(ss2);		   
			foreach(string[] ch in res)
			{
				String[] st_t = new String[3];
				st_t[0] = ch[0];
				st_t[1] = ch[1];
				st_t[2] = ch[2];
				res_T.Push(st_t);	
			}
			
			foreach (string[] ch in res_T)
			{
				Console.WriteLine(ch[0] + " " + ch[1] + " " + ch[2] + " ");
				ListViewItem item = new ListViewItem();      
				item.Text = ch[0];
				item.SubItems.Add(ch[1]);
				item.SubItems.Add(ch[2]);
				listView1.Items.Add(item);
			}


		}

		private void textBox1_TextChanged(object sender, EventArgs e)
		{

		}

		private void button9_Click(object sender, EventArgs e)
		{
			string st = textBox1.Text;
			string ss = addConnect(st);
			textBox2.Text = ss;
		}

		private void button10_Click(object sender, EventArgs e)
		{
			string st = textBox1.Text;
			string ss = addConnect(st);
			string ss1 = change(ss);
			textBox3.Text = ss1;
		}

		private void button2_Click(object sender, EventArgs e)
		{
			System.Environment.Exit(0);
		}
	}
}

public class Stack
{

	private int maxSize;// 栈的大小
	private int top;
	private char[] arr;

	public Stack()
	{
		maxSize = 30;
		top = -1;
		arr = new char[maxSize];
	}

	public void push(char value)
	{ // 压入数据

		arr[++top] = value;
	}

	public char pop()
	{ // 弹出数据

		return arr[top--];
	}

	public char peek()
	{ // 访问栈顶元素

		return arr[top];
	}

	public bool isFull()
	{ // 栈是否满了

		return maxSize - 1 == top;
	}

	public bool isEmpty()
	{ // 栈是否为空

		return top == -1;
	}

	public int length()
	{
		return top + 1;
	}

	public String getString()
	{
		if (top == -1)
			return "";
		String s = "";
		int point = 0;
		while (point <= top)
		{
			s += arr[point];
			point++;
		}
		return s;
	}
}
赵 磊
关注
  • 4
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
正规文法转正规式+正规式NFA（完整可运行代码）
09-10
（1）正规文法转正规式： 本程序的数据结构是string类的字符串存储变量，首先，读入的是3型文法，即正规文法，关于文法的检验这里就不再进行（因为第一个实验里已经实现了），读入的还有一个flag，flag为0即为左线性，为1为右线性，对读入的文法先进行第一次归类，即正规式左部相同的放在一起，本程序使用vector容器实现的对象放置，然后对所有的没有外部依赖的元素进行整合，最后依据没有外部依赖的整合后的表达式对其他的正规文法进行转换，最终得到转换结果。 （2）正规式NFA 本程序有很多数据结构，但最终的目的数据结构是存储转化好的NFA图的单元cell，里面包含起点、终点、边数以及边集合。 先读入正规式，并对正规式进行合法检测，将正规式中填入连接符号“+”，然后将其转化成后缀表达式，根据后缀表达式，对每一个操作符和操作数进行处理，处理的数据结构为cell类型的堆栈，处理完后，将最终栈内唯一的目的cell元素出栈，最后将其用二维数组的形式展现出来。 输入文件样例： a($|((a|d)(a|d)*))
正规式转化成NFA
10-25
因为在词法分析时为了分析的方便我们有时要用到正规式，有时要用到DFA，而有时可能还要用到NFA。这三种工具在词法分析时互相参照，互相补充。词法分析器的自动产生语言LEX编译器的工作过程是首先根据正规式产生出NFA，再由NFA构造出DFA，再来产生我们的词法分析器。因此，我们设计的目的是来模仿其中的一个步骤，设计的任务是根据不同的输入正规式转化成NFA的形式输出，输出形式为M={S0，S，&, $, F }五元式的形式
正规式到NFA的转换
05-02
正规式转换的3种算法，用C++实现的，还有NFA到DFA的转换，还有DFA的最小化
C# 词法分析器（四）构造 NFA
awks4002的博客
09-14 201
ref:http://www.cnblogs.com/cyjb/p/LexerNfa.html 转载于:https://www.cnblogs.com/listenerln/p/7521174.html
词法分析(5)---从正规式到NFA
Jenhy的专栏
06-24 5186
在说到这个问题前，先告诉大家，我们可以直接从 Regular expression 到 DFA，不过这里我们先不讨论这个问题关于RE到DFA的算法有很多，这里学习一个最简单的Algorithm Thompsons construction：Input : 一个字母表(Σ)上的 Regular Experssion rOutput : 一个接受 L(r) 的 NFA NMethod : 把 r 解
正规式转NFA转DFA转MFA
11-26
综上所述，"正规式转NFA转DFA转MFA"项目是关于形式语言理论的Python实现，它涵盖了正规式与有限自动机之间的转换，并提供了图形化的表示方式，便于理解和调试。通过学习和理解这个项目，可以深入理解这些抽象概念，...
用Java做编译原理正规式转换成NFA.rar
07-05
本资源“用Java做编译原理正规式转换成NFA.rar”主要关注的是编译原理中的一个重要概念——正规式到非确定性有限自动机（NFA）的转换。下面我们将深入探讨这个主题。 正规式是描述有限语言的数学表达式，常用于定义...
正规式转换成自动机的图形表示
09-11
编译原理实验作业，包括正规式转NFA，NFA转DFA，以及DFA最小化。 参考了网上很多代码，可能会有些乱，有实验报告，可以按照实验报告截图操作。试了很多表达式，最后转化的都是正确的，当做实验作业已经够用了。
Thompson转换正规式为NFA.zip
11-02
标题“Thompson转换正规式为NFA.zip”指的是一个压缩包文件，其中包含了将正规式转化为非确定性有限状态自动机（NFA）的相关代码。这个过程是编译原理中的一个重要概念，它允许我们用数学模型来处理正则表达式的匹配...
正规表达式转NFA
10-24
编译原理中的正规表达式转NFA，比较完美，不过没有判断点连接符号和正闭包。
正则表达式转NFA实现
10-21
正则表达式
编译原理 NFA_DFA 画图 C#
11-28
编译原理老师布置的作业要求程序实现NFA_DFA，然后还要输出图像，这个程序是读取一个txt文档数据然后输出一个DFA图，生产txt文档的程序是用c++写的，在我上传的另一个资源里，这两个一起用会有奇效喔
正规式与有限自动机一（文法转NFA）
Willy__QI的博客
11-08 5411
正规式转NFA由以下几种基础的情况组成： （1）单个字符 （2）并运算 （3）连接运算 （4）闭包运算 针对非操作符以及各种操作符的详细处理： 　　　1' 当遇到左括号’(‘时：直接压入栈中即可； 　　　2' 当遇到右括号')'时：依次弹出符号栈中的符号直到遇到'('为止。在依次弹出符号栈中的符号时对NFA栈中的NFA元素的操作是：弹出NFA栈顶的两个元素，进行...
正规式转NFA
weixin_45633417的博客
12-16 1590
#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
热门推荐
elice_的博客
06-02 3万+
教材《编译原理》（龙书）第2版基础知识：正规式转换成NFA的规则(也可以参考《编译原理》（龙书）第2版的第100页)1）（a）R=AB     （b）R=A|B     （c）R=A*PS:按照教材的规则r=s|tr=str=s*2）例题3.26：为正则表达式r=(a|b)*abb构造一个NFA①对于（a|b）中的a构造NFA②对于（a|b）中的b构造NFA③而（a|b）构造NFA，将上面两个图合...
编译原理：正则表达式/正规式转NFA（原理+完整代码+可视化实现）
最新发布
Toby的博客
12-04 4588
本文为做编译原理实践时候有感而发写的文章，主要内容是将正规表达式转换为NFA，欢迎学习参考！
正规式转换为NFA代码实现
Carmelo_7的博客
10-11 6055
问题引入 正规式是一种编译原理课程中经常提到的描述文法的语法规则，与正则表达式有相同之处，但并不是同一个概念。有效的正规式的字母表∑ = { a − z , A − Z } 。 所有的正规式中的符号以及对应的规则如下： ‘*’：表示闭包； ‘|’：表示联合（或）——在有的版本中也用’+'来表示； ‘.’：表示连接（与）； NFA（non-deterministic finite automaton with ε-move,ε-NFA）带空移动的非确定的有穷状态自动机 从正规式到NFA的转换是编译原理课程中经
【编译原理】正规式转换成NFA
零碎@流年絮语 的博客
05-28 1万+
非确定有限自动机（NFA） 状态转换图 状态转换矩阵 识别语言 Σ中的符 ∑ 正规式转换成NFA 例题 具体步骤 NFA 转化成 DFA 子集法 这个表是从NFA到DFA的时候必须要用到的。 第一列第一行I的意思是从NFA的起始节点经过任意个ε所能到达的结点集合。 Ia表示从该集合开始经过一个a所能到达的集合，经过一个a的意思是可以略过前后的ε。同样Ib也就是经过一个b，可以略过前后任意个ε。 至于第二行以及后面的I是怎么确定的。我参考了一些题目才明白，原来就是看上面的Ia和Ib哪个还没出现在I列
正规表达式 转 NFA C++
06-11
实现正则表达式转NFA的算法有很多种，其中比较常用的是Thompson算法。下面是一个简单的C++实现： ```c++ #include #include #include using namespace std; // NFA的状态结构体 struct State { char symbol; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值