编译原理：算符优先分析实验

已于 2022-07-13 23:39:00 修改
阅读量3.6k 收藏 103
点赞数 12
分类专栏： 编译原理 文章标签： 数据结构 算法
于 2022-07-13 23:36:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Believer_YU/article/details/125774927
版权

什么是算符优先分析法
算符优先分析法是一种简单、直观的自下而上分析法
算符优先分析法就是仿照算术表达式的四则运算过程而设计的一种语法分析方法。
这种分析方法首先要规定运算符之间（确切地说终结符之间）的优先关系和结合性质，然后借助这种关系，比较相邻运算符的优先级来确定句型的可归约串并进行归约。

分析步骤为：
1、扩展文法
S’ →#S#

2、求FIRSTVT()和LASTVT()集合
firstvt(S)={ a,^,( }
firstvt(T)={ , } ∪ firstvt(S) = {, ,a,^,( }
lastvt(S)= { a,^,) }
lastvt(T) = { , } ∪ lastvt(S) = { , ,a,^,) }

3、求优先关系
3.1 首先找 等于关系(两个vt之间只隔一个vn)
3.2 低于关系(vt在右，vn在左)
3.3 高于关系(vn在左，vt在右)
4、构造优先关系表
5、算符优先分析过程

一、实验目的

运用算符优先语法分析的基本原理实现对于句子的语法分析

二、实验要求

1、文法及待分析符号串由用户输入
2、数据结构可自行设计

三、实验内容

1、任意输入一个文法，判断它是否为简单优先文法
2、如果是，请构造该文法对应的简单优先分析表
3、输入一个字符串，判断它是否为该文法的一个句子。

四、实验代码

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <stack>
#include <iomanip>
#include <cstdlib>

using namespace std;

string V[100][2]; //存储拆分后的文法
int vi = 0; //存储拆分后有多少行
int t = 0;
int s = 0;
int l;
int r;

string FIRSTVT[20][2]; //存储firstvt集
string LASTVT[20][2]; //存储lastvt集
string str; //存储输入文法
string str_a = "#"; // 下堆栈
string str_b; // 剩余输入串
string analysis_table[100][5]; // 文法分析过程

char table[100][100]; // 算符优先关系表

void init_string(string &a) // 删除字符串的第一个元素
{
	for (int i = 1; i <= a.length(); ++i)
	{
		a[i - 1] = a[i];
	}
}

bool is_CHAR(char c) // 判断是否为大写字母
{
	if (c >= 'A' && c <= 'Z')
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool is_in(int i, string x) // 判断从字符串x从最好一个开始算起连续的i个字符是否含有非大写字母
{
	bool flag = false;
	for (int j = 0; j < i; j++)
	{
		if (!is_CHAR(x[x.length() - j - 1]))
		{
			flag = true;
		}
	}
	return flag;
}

void split(string a) // 拆分文法，使其不含有｜
{
	for (int i = 3; i < a.length(); ++i)
	{
		V[vi][0] = a[0];
		while (a[i] != '|' && i < a.length())
		{
			V[vi][1] += a[i];
			i++;
		}
		vi++;
	}
}

void read_file(string file_path) //按行读取文件
{
	fstream f;
	f.open(file_path.c_str());
	vector<string> words;
	string line;
	while (getline(f, line))
	{
		words.push_back(line);
	}
	cout << "输入文法:" << endl;
	for (int i = 0; i < words.size(); i++)
	{
		cout << words[i] << endl;
		split(words[i]);
	}
}

int find_index(char a) //寻找字符a在firstvt或者lastvt中的位置
{
	for (int i = 0; i < t; ++i)
	{
		if (FIRSTVT[i][0][0] == a)
		{
			return i;
		}
	}
	return -1;
}

int find_table_index(char a) //寻找字符a在算符优先关系表中的位置
{
	for (int i = 0; i <= s; ++i)
	{
		if (table[i][0] == a)
		{
			return i;
		}
	}
	return -1;
}

void get_start() //获取非终结符
{
	for (int i = 0; i < vi; ++i)
	{
		bool flag = true;
		for (int j = 0; j < t; ++j)
		{
			if (FIRSTVT[j][0] == V[i][0])
			{
				flag = false;
			}
		}
		if (flag)
		{
			FIRSTVT[t][0] = V[i][0];
			LASTVT[t][0] = V[i][0];
			t++;
		}
	}
}

void add_firstvt(string b, int a) //判断字符串b是否在序号为a的firstvt中，没有则加入
{
	for (int s = 0; s < b.length(); ++s)
	{
		bool flag = true;
		char c = b[s];
		if (c <= 'Z' && c >= 'A')
		{
			continue;
		}
		for (int i = 0; i < FIRSTVT[a][1].length(); ++i)
		{
			if (c == FIRSTVT[a][1][i])
			{
				flag = false;
			}
		}
		if (flag)
		{
			FIRSTVT[a][1] += c;
		}
	}
}

void add_firstvt(char c, int a) //判断字符c是否在序号为a的firstvt中，没有则加入
{
	bool flag = true;
	for (int i = 0; i < FIRSTVT[a][1].length(); ++i)
	{
		if (c <= 'Z' && c >= 'A')
		{
			continue;
		}
		if (c == FIRSTVT[a][1][i])
		{
			flag = false;
		}
	}
	if (flag)
	{
		FIRSTVT[a][1] += c;
	}
}

void add_lastvt(string b, int a) //判断字符串b是否在序号为a的lastvt中，没有则加入
{
	for (int s = 0; s < b.length(); ++s)
	{
		bool flag = true;
		char c = b[s];
		if (c <= 'Z' && c >= 'A')
		{
			continue;
		}
		for (int i = 0; i < LASTVT[a][1].length(); ++i)
		{
			if (c == LASTVT[a][1][i])
			{
				flag = false;
			}
		}
		if (flag)
		{
			LASTVT[a][1] += c;
		}
	}
}

void add_lastvt(char c, int a) //判断字符串c是否在序号为a的lastvt中，没有则加入
{
	bool flag = true;
	for (int i = 0; i < LASTVT[a][1].length(); ++i)
	{
		if (c <= 'Z' && c >= 'A')
		{
			continue;
		}
		if (c == LASTVT[a][1][i])
		{
			flag = false;
		}
	}
	if (flag)
	{
		LASTVT[a][1] += c;
	}
}

string get_cur_firstvt(char c, int a) //获取当前字符的firstvt，并放入序号为a的firstvt中
{
	string temp;
	for (int i = 0; i < vi; ++i)
	{
		if (c == V[i][0][0])
		{
			if (!(V[i][1][0] <= 'Z' && V[i][1][0] >= 'A'))
			{
				add_firstvt(V[i][1][0], a);
			}
			else
			{
				if (c != V[i][1][0])
				{
					temp = get_cur_firstvt(V[i][1][0], find_index(V[i][1][0]));
					add_firstvt(temp, a);
				}
				if (V[i][1].length() > 2)
				{
					if (!(V[i][1][1] <= 'Z' && V[i][1][1] >= 'A'))
					{
						add_firstvt(V[i][1][1], a);
					}
				}
			}
		}
	}
	return FIRSTVT[a][1];
}

string get_cur_lastvt(char c, int a) //获取当前字符的lastvt，并放入序号为a的lastvt中
{
	string temp;
	for (int i = 0; i < vi; ++i)
	{
		int s = V[i][1].length();
		if (c == V[i][0][0])
		{
			if (!(V[i][1][s - 1] <= 'Z' && V[i][1][s - 1] >= 'A'))
			{
				add_lastvt(V[i][1][s - 1], a);
			}
			else
			{
				if (c != V[i][1][s - 1])
				{
					temp = get_cur_lastvt(V[i][1][s - 1], find_index(V[i][1][0]));
					add_lastvt(temp, a);
				}
				if (V[i][1].length() > 2)
				{
					if (!(V[i][1][s - 2] <= 'Z' && V[i][1][s - 2] >= 'A'))
					{
						add_lastvt(V[i][1][s - 2], a);
					}
				}
			}
		}
	}
	return LASTVT[a][1];
}


void get_firstvt() //获取所有文法的firstvt
{
	for (int i = 0; i < t; i++)
	{
		get_cur_firstvt(FIRSTVT[i][0][0], i);
	}
}

void get_lastvt() //获取所有文法的lastvt
{
	for (int i = 0; i < t; i++)
	{
		get_cur_lastvt(LASTVT[i][0][0], i);
	}
}

void print_firstvt(string t, string a) //打印非终极符为t的firstvt
{
	cout << "FIRSTVT(" << t << ") = {";
	for (int i = 0; i < a.length(); ++i)
	{
		if (i == a.length() - 1)
		{
			cout << "\"" << a[i] << "\"";
		}
		else
		{
			cout << "\"" << a[i] << "\"" << ", ";
		}
	}
	cout << "}" << endl;
}

void print_lastvt(string t, string a) //打印非终结符为t的lastvt
{
	cout << "LASTVT(" << t << ") = {";
	for (int i = 0; i < a.length(); ++i)
	{
		if (i == a.length() - 1)
		{
			cout << "\"" << a[i] << "\"";
		}
		else
		{
			cout << "\"" << a[i] << "\"" << ", ";
		}
	}
	cout << "}" << endl;
}

void init_table() //初始化算符优先关系表
{
	table[0][0] = '\\';
	for (int i = 0; i < vi; ++i)
	{
		for (int j = 0; j < V[i][1].length(); ++j)
		{
			bool flag = true;
			for (int k = 0; k < s + 1; ++k)
			{
				if (table[k + 1][0] == V[i][1][j] || (V[i][1][j] <= 'Z' && V[i][1][j] >= 'A'))
				{
					flag = false;
				}
			}
			if (flag)
			{
				table[s + 1][0] = V[i][1][j];
				table[0][s + 1] = V[i][1][j];
				s++;
			}
		}
	}
	for (int l = 1; l < s + 1; ++l)
	{
		for (int i = 1; i < s + 1; ++i)
		{
			table[l][i] = ' ';
		}
	}
}

void get_table() //生成算符优先关系表
{
	for (int i = 0; i < vi; ++i)
	{
		for (int j = 0; j < V[i][1].length(); ++j)
		{
			//ab
			if (!(V[i][1][j] <= 'Z' && V[i][1][j] >= 'A') && !(V[i][1][j + 1] <= 'Z' && V[i][1][j + 1] >= 'A') &&
				j + 1 < V[i][1].length())
			{
				table[find_table_index(V[i][1][j])][find_table_index(V[i][1][j + 1])] = '=';
			}
			//aQb
			if ((!(V[i][1][j] <= 'Z' && V[i][1][j] >= 'A')) && (V[i][1][j + 1] <= 'Z' && V[i][1][j + 1] >= 'A') &&
				(!(V[i][1][j + 2] <= 'Z' && V[i][1][j + 2] >= 'A')) && j + 2 < V[i][1].length())
			{
				table[find_table_index(V[i][1][j])][find_table_index(V[i][1][j + 2])] = '=';
			}
			//aQ
			if ((!(V[i][1][j] <= 'Z' && V[i][1][j] >= 'A')) && (V[i][1][j + 1] <= 'Z' && V[i][1][j + 1] >= 'A') &&
				j + 1 < V[i][1].length())
			{
				for (int k = 0; k < FIRSTVT[find_index(V[i][1][j + 1])][1].length(); ++k)
				{
					table[find_table_index(V[i][1][j])][find_table_index(
							FIRSTVT[find_index(V[i][1][j + 1])][1][k])] = '<';
				}
			}
			//Qa
			if ((V[i][1][j] <= 'Z' && V[i][1][j] >= 'A') && !(V[i][1][j + 1] <= 'Z' && V[i][1][j + 1] >= 'A') &&
				j + 1 < V[i][1].length())
			{
				for (int k = 0; k < LASTVT[find_index(V[i][1][j])][1].length(); ++k)
				{
					table[find_table_index(LASTVT[find_index(V[i][1][j])][1][k])][find_table_index(
							V[i][1][j + 1])] = '>';
				}
			}
		}
	}
}


void print_table() //打印算符优先关系表
{
	for (int i = 0; i < s + 1; ++i)
	{
		for (int j = 0; j < s + 1; ++j)
		{
			cout << table[i][j] << " ";
		}
		cout << endl;
	}
}

char get_relationship(char a, char b) //获取终结符a，b的优先关系
{
	return table[find_table_index(a)][find_table_index(b)];
}

bool is_reduce() //判断是否可以规约
{
	for (int i = 0; i < vi; ++i)
	{
		int count = 0;
		int f = str_a.length() - 1;
		for (int j = V[i][1].length() - 1; j >= 0 && f >= 0; j--, f--)
		{
			if (is_in(V[i][1].length(), str_a))
			{
				if (is_CHAR(str_a[f]) && is_CHAR(V[i][1][j]))
				{
					count++;
				}
				else if (str_a[f] == V[i][1][j])
				{
					count++;
				}
			}
			else
			{
				continue;
			}
		}
		if (count == V[i][1].length())
		{
			r = i;
			return true;
		}
	}
	return false;
}


void analyze_input_string() // 生成算符优先文法的分析过程
{
	analysis_table[0][0] = "步骤";
	analysis_table[0][1] = "下堆栈";
	analysis_table[0][2] = "优先关系";
	analysis_table[0][3] = "剩余输入串";
	analysis_table[0][4] = "移进或规约";
	str_b = str;
	char relationship;
	l = 1;
	int x;
	stringstream ss;
	while (true)
	{
		ss << l;
		int index = str_a.length() - 1;
		analysis_table[l][0] = ss.str();
		analysis_table[l][3] = str_b;
		analysis_table[l][1] = str_a;
		ss.clear();
		ss.str("");
		if (is_CHAR(str_a[index]))
		{
			for (int i = str_a.length() - 1; i >= 0; i--)
			{
				if (!is_CHAR(str_a[i]))
				{
					index = i;
					break;
				}
			}
		}
		relationship = get_relationship(str_a[index], str_b[0]);
		analysis_table[l][2] = relationship;
		if (relationship == '=')
		{
			if (str_a[index] == '#' && str_b[0] == '#')
			{
				analysis_table[l][4] = "完成";
				break;
			}
			else
			{
				analysis_table[l][4] = "移进";
				str_a += str_b[0];
				analysis_table[l + 1][1] = str_a;
				init_string(str_b);
			}
		}
		else if (relationship == '<')
		{
			analysis_table[l][4] = "移进";
			str_a += str_b[0];
			analysis_table[l + 1][1] = str_a;
			init_string(str_b);
		}
		else if (relationship == '>')
		{
			if (is_reduce())
			{
				analysis_table[l][4] = "规约";
				str_a[str_a.length() - V[r][1].length()] = V[r][0][0];
				str_a.erase(str_a.length() - V[r][1].length() + 1, V[r][1].length() - 1);
			}
			else
			{
				cout << "输入串非法" << endl;
				exit(-1);
			}
		}
		l++;
	}
}

void print_analyze_process() //打印算符优先文法的分析过程
{
	cout << "算符优先分析过程" << endl;
	cout << setw(12) << analysis_table[0][0] << setw(16) << analysis_table[0][1] << setw(16) << analysis_table[0][2]
		 << setw(24)
		 << analysis_table[0][3] << setw(20)
		 << analysis_table[0][4] << endl;
	for (int i = 1; i <= l; ++i)
	{
		cout.width(10);
		cout << analysis_table[i][0];
		cout.width(12);
		cout << analysis_table[i][1];
		cout.width(10);
		cout << analysis_table[i][2];
		cout.width(20);
		cout << analysis_table[i][3];
		cout << analysis_table[i][4];
		cout << endl;
	}
}

int main(int argv, char *arg[])
{
	cout.setf(std::ios::left);
	read_file("D:\\in.txt");
	cout << "拆分后文法:" << endl;
	for (int i = 0; i < vi; ++i)
	{
		cout << V[i][0] << "->" << V[i][1] << endl;
	}
	cout << "非终结符:" << endl;
	get_start();
	for (int j = 0; j < t; ++j)
	{
		cout << FIRSTVT[j][0] << endl;
	}
	cout << "FIRSTVT:" << endl;
	get_firstvt();
	for (int k = 0; k < t; ++k)
	{
		print_firstvt(FIRSTVT[k][0], FIRSTVT[k][1]);
	}
	cout << "LASTVT:" << endl;
	get_lastvt();
	for (int k = 0; k < t; ++k)
	{
		print_lastvt(LASTVT[k][0], LASTVT[k][1]);
	}
	cout << "算符优先关系表" << endl;
	init_table();
	get_table();
	print_table();
	cout << "请输入文法并以#结束:" << endl;
	cin >> str;
	analyze_input_string();
	print_analyze_process();
	return 0;
}

//E→E+T∣T

//T→T*F∣F

//F→(E)∣i

五、测试结果

1.从文件中读取文法，然后构造优先表
2.输入待分析串，输出分析过程
in.txt中文法为：
S->#E#
E->E+T|T
T->T*F|F
F->(E)|i
在这里插入图片描述

在这里插入图片描述

Believer_YU
关注
  • 12
    点赞
  • 踩
  • 103
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编译原理实验二——算符优先分析法设计与实现
08-29
用算符优先分析方法设计一个分析解释程序，对输入的赋值语句、输出语句、清除语句进行词法分析、语法分析、表达式求值并存储于指定变量中；若存在错误，提示错误相关信息。
编译原理实验——利用算符优先分析方法设计一个计算器
09-23
（Python实现，注释详细）直接输入：3+4*5，一般的...(1)第一阶段，运用算符优先分析算法完成计算器中对算术表达式的语法分析； (2)第二阶段，设计属性文法，改造第一阶段的程序，完成算术表达式的计算和相关的输出。
算符优先分析程序设计实验【Java版】
蛙广志
11-28 1461
一、实验目的 根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式是否正确。通过算符优先分析方法的实现，加深对自下而上语法分析方法的理解。 二、大致思路 构建FirstVT级和LastVT集 构建算符优先表 进行表达式正确性分析 三、伪代码构建 构建FirstVT集 /*求 FirstVT 集的算法*/ PROCEDURE insert(P,a); IF not F[P,a] then begin F[P,a] = true; //(P,a)进栈 end
[编译原理] 算符优先分析实验报告
nebois的博客
05-24 976
算符优先分析法的基本思想是，为每个运算符赋予一个优先级，然后利用这些优先级来确定运算符之间的顺序。在算符优先分析法中，每个运算符都有一个左优先级和一个右优先级，用来指示它在与相邻运算符结合时的优先级。通常，左结合性指示运算符与其左边的运算符结合，右结合性指示运算符与其右边的运算符结合。算符优先分析法的优点是简单而高效，特别适用于具有相对简单运算符优先级关系的表达式。然而，对于包含复杂优先级规则的表达式，算符优先分析法可能无法适应，需要使用其他更复杂的语法分析方法。3.实验算法及流程图。
编译原理考题里面的知识点
Claire的博客
01-03 1690
1、基本块的概念（P152） 局部优化是指对代码的每一个线性部分所进行的优化，使得在这个线性部分只存在一个入口和一个出口，而这个线性部分我们称之为基本块 所谓基本块，是指程序中一顺序执行的语句序列，其中只有一个入口和一个出口，入口就是该序列的第一个语句，出口就是该序列的最后一个语句。对一个基本块来说，执行时只能从其入口进入，从其出口退出。 例题： 2.程序的基本块是指（ D）。 A． 一个子程序 B． 一个仅有一个入口和一个出口的语句 C． 一个没有嵌套的程序段 D． 一组顺序执行的程序段，仅有一个
编译原理实验3-算符优先分析法
http://kingim.cn/
10-26 6123
#include #include #include #include #define SIZE 128 char priority[6][6]; //算符优先关系表数组 char input[SIZE]; //存放输入的要进行分析的句子 char remain[SIZE]; //存放剩余串 char AnalyseStack[SIZE]; //分析栈 void analyse(
编译原理实验课程设计算符优先分析
07-18
编译原理实验课程设计算符优先分析，有详细源代码
【南华大学编译原理】算符优先分析及源码（带源码）
05-13
它的任务是在实验一（词法分析器）的基础上，用算符优先法、递归下降分析法、LL(1)分析法或LR分析法之一，对赋值语句进行语法分析，使其能够判断语句是否正确。通过编制语法分析程序，实现语法分析，加深对自上而下...
编译原理实验算符优先算法
05-07
编译原理课程实验报告，附加源代码，给力哦！
编译原理实验三：算符优先分析算法的设计与实现（python）
CK_0ff的博客
12-15 2218
利用python，根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式是否正确。通过算符优先分析方法的实现，加深对自下而上语法分析方法的理解。
算符优先分析法
05-22
设有文法G[S]：S→SaF | F F→FbP | P P→c | d (1) 构造G[S]的算符优先关系表 (2) 分别给出cadbdac# 和 dbcabc# 的分析过程
算符优先分析算法（实验报告）
12-15
三 设计源码 算符优先分析器 #include "stdio.h" #include "stdlib.h" #include "iostream.h" char data[20][20]; //算符优先关系 char s[100]; //模拟符号栈s char lable[20]; //文法终极符集 char input[100]; //文法输入符号串 char string[20][10]; //用于输入串的分析 int k; char a; int j; char q; int r; //文法规则个数 int r1;
编译原理实验（三）—— 算符优先分析算法的设计与实现（C语言实现）
wowhhhgd的Blog
01-12 6497
大家好，下面介绍的是我当时上编译原理所做的实验，主要内容就是根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式是否正确。用的是最基本的C语言写的，如有不足，欢迎大家批评指正！ 一、 实验目的 根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式是否正确。通过算符优先分析方法的实现，加深对自下而上语法分析方法的理解。 二、 实验内容 1、输入文法。可以是如下算术表达式的文法（你可以根据需要适当改变）： E→E+T|E-T|T T→T*F|T/F|F F→（E）|i 2、对给定表达式进
算符优先语法分析设计原理与实现
m0_60405761的博客
03-22 1325
编译原理算符优先文法分析程序
编译原理 实验3《算符优先分析法设计与实现》
渣渣的夏天
08-04 1万+
实验3《算符优先分析法设计与实现》 一、实验目的   加深对语法分析器工作过程的理解；加强对算符优先分析法实现语法分析程序的掌握；能够采用一种编程语言实现简单的语法分析程序；能够使用自己编写的分析程序对简单的程序段进行语法翻译。 二、实验内容   在实验1的基础上，用算符优先分析法编制语法分析程序，语法分析程序的实现可以采用任何一种编程语言和工具。 三、实验方法   1．实验采用C++程序语言进行...
编译原理实验：自下而上的语法分析---(算符优先分析)
拾灬Tao的博客
06-08 4351
** 算符优先分析程序(NCWU慎用) ** 1．实验要求 ⑴ 选择算符优先分析方法； ⑵ 选择对各种常见程序语言都用的语法结构，如赋值语句或表达式或控制流语句等作为分析对象，并且与所选语法分析方法要比较贴切。 ⑶ 实验时间为6学时。 2．实验内容及要求 （1）根据给定文法，先求出FirstVt和LastVt集合，构造算符优先关系表（要求算符优先关系表 输出到显示器或者输出到文件）； （2）根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式（要求输出归约过程） （3）假如给定表达式文
郑州大学编译原理实验三算符优先分析算法JAVA
热门推荐
[ 25'h ]
11-04 1万+
郑州大学编译原理实验三算符优先分析算法JAVA
编译原理实验（算符优先文法）
weixin_30535913的博客
07-25 1552
work.h1#include<iostream>2#include<stdlib.h>3#include<stdio.h>4#include<string.h>56/*************STRUCT*************/7#ifndefkeyword8#definekeyword9/*10*...
实验三 算符优先分析算法的设计与实现
m0_46336221的博客
03-11 6507
实验三：算符优先分析算法的设计与实现
编译原理实验算符优先分析算法
最新发布
12-02
算符优先分析法是一种自下而上的语法分析方法，它可以用于分析和处理算术表达式、布尔表达式等。下面是算符优先分析法的实现步骤： 1. 定义终结符和非终结符：终结符是指不能再分解的基本符号，如数字、运算符等；非终结符是指可以分解成其他符号的符号，如表达式、语句等。 2. 定义运算符之间的优先关系和结合性质：将运算符按照优先级从高到低排列，相同优先级的运算符再按照结合性质（左结合或右结合）进行排列。 3. 构造算符优先关系表：根据定义的运算符优先关系和结合性质，构造算符优先关系表。表中的行和列分别表示两个相邻的运算符，表中的元素表示它们之间的优先关系（“<”表示优先级低，“>”表示优先级高，“=”表示优先级相等）。 4. 进行语法分析：将输入的表达式转换成一个个终结符和非终结符的序列，然后根据算符优先关系表进行分析。具体地，从左到右扫描输入序列，将扫描到的符号压入栈中，同时比较栈顶符号和下一个输入符号之间的优先关系，如果栈顶符号的优先级低于或等于下一个输入符号的优先级，则将下一个输入符号压入栈中；否则，从栈中弹出一个或多个符号进行归约，直到栈顶符号的优先级低于或等于下一个输入符号的优先级。 5. 进行表达式求值：在进行归约时，如果遇到两个相邻的终结符之间有一个运算符，则可以对它们进行求值，并将结果压入栈中。最终，栈中只剩下一个值，即为表达式的值。 下面是一个简单的算符优先分析法的实现例子，用于分析和处理四则运算表达式： ```python # 定义终结符和非终结符 terminals = ['+', '-', '*', '/', '(', ')', 'num'] non_terminals = ['E', 'T', 'F'] # 定义运算符之间的优先关系和结合性质 precedence = { '+': {'+': '>', '-': '>', '*': '<', '/': '<', '(': '<', ')': '>', 'num': '<'}, '-': {'+': '>', '-': '>', '*': '<', '/': '<', '(': '<', ')': '>', 'num': '<'}, '*': {'+': '>', '-': '>', '*': '>', '/': '>', '(': '<', ')': '>', 'num': '<'}, '/': {'+': '>', '-': '>', '*': '>', '/': '>', '(': '<', ')': '>', 'num': '<'}, '(': {'+': '<', '-': '<', '*': '<', '/': '<', '(': '<', ')': '=', 'num': '<'}, ')': {'+': '>', '-': '>', '*': '>', '/': '>', '(': ' ', ')': '>', 'num': ' '}, 'num': {'+': '>', '-': '>', '*': '>', '/': '>', '(': ' ', ')': '>', 'num': ' '} } # 构造算符优先关系表 table = {} for i in range(len(terminals)): table[terminals[i]] = {} for j in range(len(terminals)): table[terminals[i]][terminals[j]] = precedence[terminals[i]][terminals[j]] # 进行语法分析 def parse(expr): stack = ['#'] tokens = expr.split() for token in tokens: while table[stack[-1]][token] == '>': op = stack.pop() if op in ['+', '-', '*', '/']: b = stack.pop() a = stack.pop() stack.append(str(eval(a + op + b))) else: stack.pop() if table[stack[-1]][token] == '<' or table[stack[-1]][token] == '=': stack.append(token) else: raise ValueError('Invalid expression') while stack[-1] != '#': op = stack.pop() if op in ['+', '-', '*', '/']: b = stack.pop() a = stack.pop() stack.append(str(eval(a + op + b))) else: raise ValueError('Invalid expression') return stack[0] # 进行表达式求值 expr = '3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3' result = parse(expr) print(result) # 输出：3.0001220703125 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值