编译原理词法分析（正规式转NFA）

最新推荐文章于 2024-04-07 15:22:36 发布
最新推荐文章于 2024-04-07 15:22:36 发布
阅读量4.3k 收藏 61
点赞数 12
分类专栏： 数学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43309907/article/details/110086533
版权

编译原理

文章目录

【问题描述】

正规表达式→NFA问题的一种描述是：
编写一个程序，输入一个正规表达式，输出与该文法等价的有穷自动机。

【基本要求】

设置FA初始状态X，终态Y，过程态用数字表示：0 1 2 3………

【测试用例】

测试数据：

(a|b)*abb

输出结果应为：

X X - ~ ->3
Y
0 0-a->1
1 1-b->2
2 2-b->Y
3 3-~->0 3-a->3 3-b->3

【解决步骤】

正规式转NFA方法步骤：

  1. 判断一下正规式有没有错误，括号对不对，并添加符号“+”
  2. 运算符的优先级为：*>|>+
  3. 根据符号优先级，把中缀表达式转后缀表达式便于计算
  4. 根据后缀表达式依次构建图。有三种运算：*、|、+

图的构建过程：

（1） 定义边结构体用来储存边：edge

//NFA边
struct edge{
	        int start;
	        int end;
	        char accept; 
};

（2） 定义一个类用来表示图结构：grup

//NFA单元，一个大的NFA单元可以是由很多小单元通过规则拼接起来
class grup{
public:
	       vector<edge> edges;  //这个NFA拥有的边
	      int stateCount; //状态数
	      int StartState;  //开始状态
	      int EndState;  //结束状态
public:
	       grup() {
		     this->stateCount = 2;
		     this->StartState = 0;
		     this->EndState = 1;
	        }
};

（3） 构建出的图结构边是从状态是从0开始编号的 构建过程：以(a|b)*abb为例

  • 输入字符串添加+号，并判断是否合法：
    算法：

    • 定义一个栈s用来匹配括号，判断括号是否符合条件。
      从左往右扫描字符串，如果是字母或数字，则放入输出表达式后
      然后判断后一个是什么符号判断是否要加上+号
      对于类似如下几种情况需要加上+的：AA、A(、A、(、)A、)(。
      完成后(a|b)abb变为：(a|b)+a+b+b

  • 中缀表达式转后缀表达式
    算法：

    • 定义一个栈s，从左忘右扫描表达式，
      遇见字母或数字拼接在输出表达式后
      遇见“（”压入栈中
      遇见“）”弹出栈中元素，直到遇到了“（”
      遇到“、|、+”判断栈顶元素的优先级，把比自己优先级高或等的弹出去
      然后自己再压栈。
      扫描完成后再把栈中元素依次弹出，拼接在输出字符串后
      完成后(a|b)      +a+b+b应该变为：ab|*a+b+b+
      核心算法：
Void change_text(string text) {
	stack<char> s;
	string new_text = "";
	for (int i = 0; i<int(text.length()); i++) {
	if ((text[i] <= 'z' && text[i] >= 'a') || (text[i] <= 'Z' && text[i] >= 'A') || (text[i]<= '9' && text[i] >= '0')) {new_text = new_text + text[i];}
		else {
			if (text[i] == '(') {s.push(text[i]);}
			else if (text[i] == ')') {
				while (s.top() != '(') {new_text = new_text + s.top();s.pop();}
				s.pop();}
			else if (text[i] == '*') {s.push(text[i]);}
			else if (text[i] == '|') {
				if (s.empty()) {s.push(text[i]);}
				else {
					while (!s.empty()) {
						if (s.top() == '*') {new_text = new_text + s.top();s.pop();}
						else if (s.top() == '|') {new_text = new_text + s.top();s.pop();}
						else {break;}
					}
					s.push(text[i]);}
			}
			else if (text[i] == '+') {
				if (s.empty()) {s.push(text[i]);}
				else {
					while(!s.empty()){
						if (s.top() == '*') {new_text = new_text + s.top();s.pop();}
else if (s.top() == '+') {new_text = new_text + s.top();s.pop();}
						else if (s.top() == '|') {new_text = new_text + s.top();s.pop();}
						else {break;}}
					s.push(text[i]);}}}}
	while(!s.empty()) {new_text += s.top();s.pop();}
	return new_text;}
  • 构架图结构：
    算法：
    • 定义一个栈用来储存图结构，从左向右扫描后缀表达式
      如果遇到的是字母或数字，构建一个如下状态的图：一条边两个状态
      1111

压入栈中
如果遇到运算符分三种情“、|、+”
遇到“”，栈顶元素出栈
1111111

遇到“+”
在这里插入图片描述

遇到“|”
在这里插入图片描述

  • 核心算法：
getNFA(string text) {
	stack<grup> s;
	for (int i = 0; i < int(text.length()); i++) {
		if ((text[i] <= 'z' && text[i] >= 'a') || (text[i] <= 'Z' && text[i] >= 'A')||(text[i] <= '9' && text[i] >= '0')) {
			grup tempG;
			edge tempE;
			tempE.accept = text[i];
			tempE.start = 0;
			tempE.end = 1;
			tempG.edges.push_back(tempE);
			s.push(tempG);
		}
		else {
			if (text[i] == '+') {
				grup tempG2 = s.top();
				s.pop();
				grup tempG1 = s.top();
				s.pop();
				//图和图合成
				grup tempG = tempG1;
				tempG.stateCount = tempG1.stateCount + tempG2.stateCount-1;
				tempG.StartState = 0;
				tempG.EndState = tempG.stateCount - 1;
				//获取后一条边
				for (int i = 0; i < int(tempG2.edges.size());i++) {
					edge e2 = tempG2.edges[i];
					e2.start += tempG1.stateCount-1;
					e2.end += tempG1.stateCount-1;
					tempG.edges.push_back(e2);
				}
				//合成图压栈
				s.push(tempG);
			}
			else if (text[i] == '*') {
				grup tempG2 = s.top();
				s.pop();
				grup tempG;
				if (tempG2.StartState!=tempG2.EndState) {
					tempG.stateCount = tempG2.stateCount + 1;
				}
				else {
					tempG.stateCount = tempG2.stateCount + 2;
				}
				tempG.EndState = tempG.stateCount-1;
				//图内的边编号加1
				for (int i = 0; i < int(tempG2.edges.size());i++) {
					edge e2 = tempG2.edges[i];
					if (e2.end==tempG2.EndState) {
						e2.start += 1;
						e2.end = e2.start;
					}
					else {
						e2.start += 1;
						e2.end += 1;
					}
					tempG.edges.push_back(e2);
				}
				//添加两条边
				edge e1;
				e1.accept = '~';
				e1.start = 0;
				e1.end = 1;
				edge e2;
				e2.accept = '~';
				e2.start = tempG.EndState-1;
				e2.end = e2.start + 1;
				tempG.edges.push_back(e1);
				tempG.edges.push_back(e2);
				//合成图压栈
				s.push(tempG);
			}
			else if (text[i] == '|') {
				grup tempG2 = s.top();
				s.pop();
				grup tempG1 = s.top();
				s.pop();
				grup tempG;
				tempG.StartState = 0;
				tempG.EndState = 0;
				tempG.stateCount = tempG1.stateCount + tempG2.stateCount-3;
				for (int i = 0; i < int(tempG1.edges.size());i++) {
					edge e1 = tempG1.edges[i];
					if (e1.end == tempG1.EndState) {
						e1.end = 0;
					}
					tempG.edges.push_back(e1);
				}
				for (int i = 0; i < int(tempG2.edges.size());i++) {
					edge e2 = tempG2.edges[i];
					if (e2.end == tempG2.EndState) {
						e2.end = 0;
					}
					tempG.edges.push_back(e2);
				}
				//合成图压栈
				s.push(tempG);
			}
		}
	}
	return s.top();
}
  • 输出图结构：
    输出时按照格式输出，构建好的图状态为0到n，把0输出为X最后一个输出为Y中间状态减一就可以了

完整代码：

#include<iostream>
#include<fstream>
#include<stack>
#include<vector>
#include<string>
#define MAX 100
using namespace std;

//NFA边
struct edge{
	int start;
	int end;
	char accept;
};

//NFA单元，一个大的NFA单元可以是由很多小单元通过规则拼接起来
class grup
{
public:
	vector<edge> edges;  //这个NFA拥有的边
	int stateCount; //状态数
	int StartState;  //开始状态
	int EndState;  //结束状态
public:
	grup() {
		this->stateCount = 2;
		this->StartState = 0;
		this->EndState = 1;
	}
};

class WordAnstary {
private :
	string input_file = "testfile.txt";
	string output_file = "output.txt";
public:
	//主函数
	int start();
	//整理字符串
	string clear_text(string text);
	//中缀表达式转后缀表达式 
	string change_text(string text);
	//根据正规式获得NFA
	grup getNFA(string text);
	//输出结果
	void printNFA(grup out);
};
//主函数
int WordAnstary::start() {
	//文件操作工具
	ifstream read_file;
	//读取文件
	string text;
	//read_file.open(input_file);
	//read_file >> text;
	cin >> text;
	//cout << text;
	//分析正规式，得到有穷自动机
	//cout << "原表达式为：" << text << endl;
	string new_text = this->clear_text(text);
	if (new_text != "") {
		cout << "添加+的表达式："<<new_text << endl;
		new_text = this->change_text(new_text);
		cout << "后缀表达式："<<new_text << endl;
		grup out = this->getNFA(new_text);
		this->printNFA(out);
	}
	else {
		cout << "输入不合法" << endl;
	}
	read_file.close();
	return 0;
};

void WordAnstary::printNFA(grup out) {
	cout << "X ";
	for (int j = 0; j < int(out.edges.size()); j++) {
		edge eX = out.edges[j];
		if (eX.start == 0) {
			cout << "X-" << eX.accept << "->";
			if (eX.end==out.stateCount-1) {
				cout << "Y ";
			}
			else {
				cout << eX.end - 1<<" ";
			}
		}
	}
	cout << endl;
	cout << "Y ";
	for (int j = 0; j < int(out.edges.size()); j++) {
		edge eX = out.edges[j];
		if (eX.start == out.stateCount - 1) {
			cout << "Y-" << eX.accept << "->";
			if (eX.end == out.stateCount - 1) {
				cout << "Y ";
			}
			else {
				cout << eX.end - 1<<" ";
			}
		}
	}
	cout << endl;
	for (int i = 1; i < out.stateCount - 1; i++) {
		cout << i - 1 << " ";
		for (int j = 0; j < int(out.edges.size()); j++) {
			edge e = out.edges[j];
			if (e.start == i&&e.accept=='~') {
				cout << e.start - 1 << "-" << e.accept << "->";
				if (e.end == out.stateCount - 1) {
					cout << "Y ";
				}
				else {
					cout << e.end - 1 << " ";
				}
			}
		}
		for (int j = 0; j < int(out.edges.size()); j++) {
			edge e = out.edges[j];
			if (e.start == i&&e.accept!='~') {
				cout << e.start - 1 << "-" << e.accept << "->";
				if (e.end == out.stateCount - 1) {
					cout << "Y ";
				}
				else {
					cout << e.end - 1<<" ";
				}
			}
		}
		cout << endl;
	}
}

grup WordAnstary::getNFA(string text) {
	stack<grup> s;
	for (int i = 0; i < int(text.length()); i++) {
		if ((text[i] <= 'z' && text[i] >= 'a') || (text[i] <= 'Z' && text[i] >= 'A')||(text[i] <= '9' && text[i] >= '0')) {
			grup tempG;
			edge tempE;
			tempE.accept = text[i];
			tempE.start = 0;
			tempE.end = 1;
			tempG.edges.push_back(tempE);
			s.push(tempG);
		}
		else {
			if (text[i] == '+') {
				grup tempG2 = s.top();
				s.pop();
				grup tempG1 = s.top();
				s.pop();
				//图和图合成
				grup tempG = tempG1;
				tempG.stateCount = tempG1.stateCount + tempG2.stateCount-1;
				tempG.StartState = 0;
				tempG.EndState = tempG.stateCount - 1;
				//获取后一条边
				for (int i = 0; i < int(tempG2.edges.size());i++) {
					edge e2 = tempG2.edges[i];
					e2.start += tempG1.stateCount-1;
					e2.end += tempG1.stateCount-1;
					tempG.edges.push_back(e2);
				}
				//合成图压栈
				s.push(tempG);
			}
			else if (text[i] == '*') {
				grup tempG2 = s.top();
				s.pop();
				grup tempG;
				if (tempG2.StartState!=tempG2.EndState) {
					tempG.stateCount = tempG2.stateCount + 1;
				}
				else {
					tempG.stateCount = tempG2.stateCount + 2;
				}
				tempG.EndState = tempG.stateCount-1;
				//图内的边编号加1
				for (int i = 0; i < int(tempG2.edges.size());i++) {
					edge e2 = tempG2.edges[i];
					if (e2.end==tempG2.EndState) {
						e2.start += 1;
						e2.end = e2.start;
					}
					else {
						e2.start += 1;
						e2.end += 1;
					}
					tempG.edges.push_back(e2);
				}
				//添加两条边
				edge e1;
				e1.accept = '~';
				e1.start = 0;
				e1.end = 1;
				edge e2;
				e2.accept = '~';
				e2.start = tempG.EndState-1;
				e2.end = e2.start + 1;
				tempG.edges.push_back(e1);
				tempG.edges.push_back(e2);
				//合成图压栈
				s.push(tempG);
			}
			else if (text[i] == '|') {
				grup tempG2 = s.top();
				s.pop();
				grup tempG1 = s.top();
				s.pop();
				grup tempG;
				tempG.StartState = 0;
				tempG.EndState = 0;
				tempG.stateCount = tempG1.stateCount + tempG2.stateCount-3;
				for (int i = 0; i < int(tempG1.edges.size());i++) {
					edge e1 = tempG1.edges[i];
					if (e1.end == tempG1.EndState) {
						e1.end = 0;
					}
					tempG.edges.push_back(e1);
				}
				for (int i = 0; i < int(tempG2.edges.size());i++) {
					edge e2 = tempG2.edges[i];
					if (e2.end == tempG2.EndState) {
						e2.end = 0;
					}
					tempG.edges.push_back(e2);
				}
				//合成图压栈
				s.push(tempG);
			}
		}
	}
	return s.top();
}

string WordAnstary::clear_text(string text) {
	//储存添加好+号的正规式
	string new_text = "";
	//分析栈用来分析()匹配
	stack<char> s;
	for (int i = 0; i < int(text.length()); i++) {
		if ((text[i] <= 'z' && text[i] >= 'a') || (text[i] <= 'Z' && text[i] >= 'A') || (text[i] <= '9' && text[i] >= '0')) {
			new_text = new_text + text[i];
			if (i < int(text.length()) - 1) {
				if ((text[i + 1] <= 'z' && text[i+1] >= 'a') || (text[i + 1] <= 'Z' && text[i + 1] >= 'A') || (text[i+1] <= '9' && text[i+1] >= '0')) {
					new_text = new_text + '+';
				}
				else if (text[i + 1] == '(') {
					new_text = new_text + '+';
				}
			}
		}
		else if (text[i] == '|') {
			new_text = new_text + text[i];
			continue;
		}
		else if (text[i] == '*') {
			new_text = new_text + text[i];
			if (i < int(text.length()) - 1) {
				if ((text[i + 1] <= 'z' && text[i+1] >= 'a') || (text[i + 1] <= 'Z' && text[i + 1] >= 'A') || (text[i] <= '9' && text[i] >= '0'))
					new_text = new_text + '+';
				else if (text[i + 1] == '(')
					new_text = new_text + '+';
			}
		}
		else if (text[i] == '(') {
			new_text = new_text + text[i];
			s.push(text[i]);
		}
		else if (text[i] == ')') {
			new_text = new_text + text[i];
			if (i < int(text.length()) - 1) {
				if ((text[i + 1] <= 'z' && text[i+1] >= 'a') || (text[i + 1] <= 'Z' && text[i + 1] >= 'A') || (text[i] <= '9' && text[i] >= '0'))
					new_text = new_text + '+';
				else if (text[i + 1] == '(')
					new_text = new_text + '+';
			}
			if (s.empty()) {
				return "";
			}
			else {
				s.pop();
			}
		}
		else
			return "";
	}
	if (s.empty())
		return new_text;
	else
		return "";
}

string WordAnstary::change_text(string text) {
	stack<char> s;
	string new_text = "";
	for (int i = 0; i<int(text.length()); i++) {
		if ((text[i] <= 'z' && text[i] >= 'a') || (text[i] <= 'Z' && text[i] >= 'A') || (text[i] <= '9' && text[i] >= '0')) {
			new_text = new_text + text[i];
		}
		else {
			if (text[i] == '(') {
				s.push(text[i]);
			}
			else if (text[i] == ')') {
				while (s.top() != '(') {
					new_text = new_text + s.top();
					s.pop();
				}
				s.pop();
			}
			else if (text[i] == '*') {
				s.push(text[i]);
			}
			else if (text[i] == '|') {
				if (s.empty()) {
					s.push(text[i]);
				}
				else {
					while (!s.empty()) {
						if (s.top() == '*') {
							new_text = new_text + s.top();
							s.pop();
						}
						else if (s.top() == '|') {
							new_text = new_text + s.top();
							s.pop();
						}
						else {
							break;
						}
					}
					s.push(text[i]);
				}
			}
			else if (text[i] == '+') {
				if (s.empty()) {
					s.push(text[i]);
				}
				else {
					while(!s.empty()){
						if (s.top() == '*') {
							new_text = new_text + s.top();
							s.pop();
						}else if (s.top() == '+') {
							new_text = new_text + s.top();
							s.pop();
						}
						else if (s.top() == '|') {
							new_text = new_text + s.top();
							s.pop();
						}
						else {
							break;
						}
					}
					s.push(text[i]);
				}
			}
		}
	}
	while(!s.empty()) {
		new_text += s.top();
		s.pop();
	}
	return new_text;
}


//int main() {
//	WordAnstary wordAustary;
//	wordAustary.start();
//}```
persistenthuang
关注
  • 12
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编译原理实验词法分析c语言,编译原理，词法分析，实验报告
weixin_33785971的博客
05-19 2254
一、实验目的通过设计、开发一个高级语言的词法分析程序，加深对课堂教学内容(包括正规文法、正规表达式、有限自动机、NFA到DFA的转换、DFA的最小化)的理解，提高词法分析方法的实践能力。二、实验要求(1)深入理解、掌握有限自动机及其应用；(2)掌握根据语言的词法规则构造识别其单词的有限自动机的方法；(3)掌握NFA到DFA的等价变换方法、DFA最小化的方法；(4)掌握设计、编码、调试词法分析程序的...
编译原理：正规式转NFA（有穷自动机）
最新发布
06-08
了解正规式转NFA的过程对于深入理解编译原理至关重要，同时它也为解决实际问题提供了强大的工具，如在文本处理、搜索算法和编程语言解析中。通过实践和理解RegularExpressionToNFA-master项目，你可以更直观地掌握这...
【编译原理】正规式转换成NFA
零碎@流年絮语 的博客
05-28 1万+
非确定有限自动机（NFA） 状态转换图 状态转换矩阵 识别语言 Σ中的符 ∑ 正规式转换成NFA 例题 具体步骤 NFA 转化成 DFA 子集法 这个表是从NFA到DFA的时候必须要用到的。 第一列第一行I的意思是从NFA的起始节点经过任意个ε所能到达的结点集合。 Ia表示从该集合开始经过一个a所能到达的集合，经过一个a的意思是可以略过前后的ε。同样Ib也就是经过一个b，可以略过前后任意个ε。 至于第二行以及后面的I是怎么确定的。我参考了一些题目才明白，原来就是看上面的Ia和Ib哪个还没出现在I列
【编译原理】词法分析（C/C++源代码+实验报告）
热门推荐
xtcc的博客
10-13 8万+
文章目录1 实验目的和内容1.1实验目的1.2实验内容2 设计思想2.1单词种类及其正规式2.2 根据正规式构造NFA2.3根据NFA构造DFA2.3.1根据替换规则构造未化简的DFA2.3.2最小化DFA3算法流程4源程序5调试数据5.1 测试样例一5.2 测试样例二5.3 测试样例三6实验调试情况及体会6.1 实验调试情况6.2 实验体会 1 实验目的和内容 1.1实验目的 （1）根据 PL/0 语言的文法规范，编写PL/0语言的词法分析程序；或者调研词法分析程序的自动生成工具LEX或FLEX，设计并实
编译原理 --- 正规式与NFA之间的转换，以及词法分析程序自动生成 --- LEX
qq_51947882的博客
10-11 3021
1.首先针对我们要分析的语言设计一个LEX源程序，并将其输入到LEX编译器中，编译完成后我们就能够得到一个用我们要分析的语言编写而成的词法分析程序，再将这个程序传给我们要分析的语言的编译器转换为机械语言后，就能够得到一个可执行的语法分析程序（.exe）2.l(r)指的是正规是r对应的正规集，而L(M)则是有限自动机能够识别的字的集合，当这二个集合相等的时候我们称正规式r和有限自动机M之间是等价。1.第三条规则中 r2 和 * 是连在一起的，求的是r2这个正规式对应的正规集进行闭包运算后得到的集合。
编译原理（三）词法分析、正规式、正规文法、NFA、DFA、最小化DFA
star_of_science的博客
06-18 9878
话不多说，本文要点总结如图： 3.1 词法分析程序的设计 词法分析（lexical analysis）功能： 逐个读入源程序字符，输出“单词符号” ，供语法分析使用。 主要任务： 读源程序，产生单词符号 其他任务： 滤掉空格，跳过注释、换行符 追踪换行标志，复制出错源程序 宏展开，…… 3.2 单词的描述工具 单词的描述工具和识别工具： 正规文法（正则文法、3型文法） 正规式（正则式） 有穷自动机（NFA、DFA） 三者之间可以相互转换 3.3 有穷自动机（FA）
词法分析程序之正规式转换成NFA
LH is programming hard
04-16 4445
文章目录前言正规式变成NFA前备知识中缀表达式和后缀表达式（细节处理）输入正规式和转换NFA测试结果完整代码 前言 编译原理课里面书本有一个作业——使用C++实现： 将正规式变成NFA NFA确定化（变成DFA） DFA最小化（化简） 自己学习过程中，深刻知道自己动手写东西是多么的重要。所以，我开始从0开始写这个作业。 每个自学的人都要明白自己和科班的人差距在哪里——基础！基础！所以一定要花时间去补回来。 正规式变成NFA 前备知识 在动手之前，一定学会分析要怎么做怎么做，有哪几个类，不要上去就是一段代
编译原理实验1（词法分析）
qq_53682472的博客
04-07 965
通过完成实验报告，可以整理相关的知识点，理清自己的思路，加深对课程的理解，所以我认为写实验报告也是很重要的。这次实验的难度其实不是很大的，主要是理解和掌握词法分析的相关内容，以及从文法到NFA到DFA的理解对编写代码尤为重要。刚开始写实验的时候确实无从下手，后面通过看书和查阅资料，更进一步地理解了实验的内容和要实现的效果，然后开始尝试写步骤、流程和程序，渐入佳境。总的来说，通过这次实验课，既加深了我对编译原理课程重点内容的理解，又复习了数据结构的相关知识，提高了编写代码的能力，收获良多。
编译原理－－词法分析
x13262608581的博客
03-04 1765
编译原理－－词法分析
编译原理词法分析
andy dennis的博客
01-04 885
前言 词法分析作为编译过程中很重要的一环，我们需要认真学习一下。(另外，若有错请及时留言，时间仓促，仅供参考) DFA 看看基本的其他的照葫芦画瓢就好了: ab a | b a* (ab)* (a | b) * ab | ac 注:考试中如果没有明确说明要从写出NFA则可以直接写出DFA NFA 如果要求写NFA或者实现算法的话，就没法直接得到DFA了。 同样看看基本的其他的照葫芦画瓢就好了: ab a | b a* (ab)* (
用Java做编译原理正规式转换成NFA.rar
07-05
本资源“用Java做编译原理正规式转换成NFA.rar”主要关注的是编译原理中的一个重要概念——正规式到非确定性有限自动机（NFA）的转换。下面我们将深入探讨这个主题。 正规式是描述有限语言的数学表达式，常用于定义...
编译原理-报告正规式转NFA转DFA转MFA1
08-08
编译原理中的正规式转换是构建词法分析器和解析器的基础，主要涉及正规式到非确定有限自动机（NFA）、NFA到确定有限自动机（DFA）以及DFA到最小化有限自动机（MFA）的转换。本文将详细阐述这些转换的原理和流程。 ...
词法分析 编译原理实验/课程设计（C++实现）
09-08
本资源是编译原理实验-词法分析，用c++语言实现，包括mysource.txt 、mytext.txt、output.txt和词法分析.cpp文件，能够实现词法分析功能 设计要求：创建一个词法分析程序，它支持对正规文法的分析。必须使用DFA...
编译原理中正规式转化为nfa
05-11
在编译原理中，正规式（Regular Expression）与非确定性有限自动机（Non-Deterministic Finite Automaton，简称NFA）是两个重要的概念。正规式主要用于描述简单的字符串模式，而NFA则是一种数学模型，用于识别正规集...
离散数学-代数系统-二元运算-16
persistenthuang
05-21 1万+
离散数学 代数系统
离散数学-代数系统-同态同构-17
persistenthuang
05-21 1万+
离散数学 代数系统 同态映射： 定义：设V1=<A,∘>和V2=<B,∗>是同类型的代数系统， f:A→B，且∀x, y∈A 有f(x∘y) = f(x)∗f(y), 则称 f 是V1到V2的同态映射，简称同态. 同态分类： 如果f是单射，则称为单同态 如果f是满射，则称为满同态，这时称V2是V1的同态像，记作V1∼ V2 如果f是双射，则称为同构，也称代数系统V1同构于V2，记作V1 ≅ V2 如果V1 = V2，则称作自同态 同态映射的判别和证明： 说明：设有代数系统V1=&
离散数学-函数-定义和性质-13
persistenthuang
04-13 9781
离散数学 函数： 函数的定义和性质： 定义： 函数相等： 函数的集合： 函数的像，完全原像： 满射、单射、双射 常用函数： 常含数：f(x)=c 恒等函数：f(x)=x 单调递增：对于x1<x2 ：f(x1)<=f(x2) 严格单调递增：对于x1<x2 ：f(x1)<f(x2) 特征函数： 自然映射： ...
离散数学-代数系统-半群与独异点，群-18
persistenthuang
05-22 8703
离散数学 代数系统 半群与独异点 定义： (1)设V=<S, ∘ >是代数系统，∘为二元运算，如果∘运算是可结合的（满足结合律），则称V为半群(semi-group) (2)设V=<S, ∘ >是半群，若e∈S是关于∘运算的单位元，则称V是含幺半群，也叫做独异点(monoid)，有时也将独异点V记作V=<S，∘ ，e> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值