算符优先

最新推荐文章于 2020-08-07 15:34:17 发布
最新推荐文章于 2020-08-07 15:34:17 发布
阅读量340 收藏 2
点赞数
分类专栏： 实验 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l__fengjin/article/details/106387849
版权

算符优先-------Java实现

实验题目
在这里插入图片描述
实验结果
在这里插入图片描述
在这里插入图片描述
1、读取文本

package by02;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class by02file {

	private ArrayList<ArrayList<String>> G = new ArrayList<ArrayList<String>>();

	private String str = "";

	public by02file() throws IOException {
		File file = new File("D://byfile02.txt");
		try {
			BufferedReader bu = new BufferedReader(new FileReader(file));
			String s = null;
			while ((s = bu.readLine()) != null) {
				str += s;
				str += '\n';
			}
			bu.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
	}

	public void getStr() {
		System.out.println(str);
	}

	public ArrayList<ArrayList<String>> PG() {
		ArrayList<String> A = new ArrayList<String>();
		//A中以字符串形式保存产生式的左部和右部候选式
		int i = 0;
		String s0 = "";
		//集合不是将对象克隆存储，而是对对象的引用，为不改之前信息，需重新定义

		while ((i < str.length())) {
			if (str.charAt(i) == '-' && str.charAt(i + 1) == '>') {
				A.add(s0);
				s0 = "";
				i += 2;
			}else if(str.charAt(i)=='|') {
				A.add(s0);
				s0="";
				i++;		
			}else if(str.charAt(i)=='\n') {
				A.add(s0);
				G.add(A);
				s0="";
				A=new ArrayList<String>();
				i++;
			}
			else {
				s0+=str.charAt(i);
				i++;
			}


		}
		return G;	
	}

}

2、FirstVt集、LastVt集及归约分析过程

package by02;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;

public class by02main {

	static ArrayList<ArrayList<String>> G = new ArrayList<ArrayList<String>>();
	static ArrayList<String> Vn = new ArrayList<String>();
	static ArrayList Vt = new ArrayList();
	static ArrayList<ArrayList> VnFirstVT = new ArrayList<ArrayList>();
	static ArrayList<ArrayList> VnLastVT = new ArrayList<ArrayList>();
	static int N = 3;

	public static void removeDuplicate(ArrayList<ArrayList> list) {// 清楚集中的重复元素
		int i = 0;
		while (i < G.size()) {
			HashSet h = new HashSet(list.get(i));
			list.get(i).clear();
			list.get(i).addAll(h);
			i++;
		}

	}

	public static void FirstVT() {
		int i = 0;
		while (i < G.size()) {// 第一遍扫描
			ArrayList A = new ArrayList();
			int j = 1;
			while (j < G.get(i).size()) {
				int t = 0;
				for (; t < 2 && t < G.get(i).get(j).length(); t++) {
					char c = G.get(i).get(j).charAt(t);
					if (Vt.contains(c)) {
						A.add(c);
						break;
					}
				}

				j++;
			}
			VnFirstVT.add(A);
			i++;
		}
//		System.out.println(VnFirstVT);
		i = 0;
		while (i < G.size()) {// 第二遍扫描
			int j = 1;
			ArrayList<String> L = new ArrayList<String>();
			int count = 0;
			while (j < G.get(i).size()) {
				String s = "";
				s += G.get(i).get(j).charAt(0);
				if (Vn.contains(s) && !s.equals(Vn.get(i))) {// 后者條件是避免自身first加入自身，無終止進行
					L.add(s);
//					System.out.println(s);
				}
				j++;
			}
			while (count < L.size()) {
				int t = Vn.indexOf(L.get(count));
				int m = 1;
				while (m < G.get(t).size()) {
					String s = "";
					s += G.get(t).get(m).charAt(0);
					if (Vn.contains(s) && !L.contains(s)) {
						L.add(s);
					}
					m++;
				}
				count++;
			}
//			System.out.println(L);
			int m = 0;
			while (m < L.size()) {
				int t = Vn.indexOf(L.get(m));
				VnFirstVT.get(i).addAll(VnFirstVT.get(t));
				m++;
			}
			i++;
		}
		removeDuplicate(VnFirstVT);// 清重复元素
		System.out.println("各非终结符的FIRSTVT集为：" + VnFirstVT);

	}

	public static void LastVT() {
		int i = 0;
		while (i < G.size()) {// 第一遍扫描
			ArrayList A = new ArrayList();
			int j = 1;
			while (j < G.get(i).size()) {
				int t = G.get(i).get(j).length() - 1;
				for (; t >= 0 && t >= G.get(i).get(j).length() - 2; t--) {
					char c = G.get(i).get(j).charAt(t);
					if (Vt.contains(c)) {
						A.add(c);
						break;
					}
				}

				j++;
			}
			VnLastVT.add(A);
			i++;
		}

		i = 0;
		while (i < G.size()) {// 第二遍扫描
			int j = 1;
			ArrayList<String> L = new ArrayList<String>();
			int count = 0;
			while (j < G.get(i).size()) {
				String s = "";
				s += G.get(i).get(j).charAt(G.get(i).get(j).length() - 1);
				if (Vn.contains(s) && !s.equals(Vn.get(i))) {// 后者條件是避免自身first加入自身，無終止進行
					L.add(s);
					// System.out.println(s);
				}
				j++;
			}
			while (count < L.size()) {
				int t = Vn.indexOf(L.get(count));
				int m = 1;
				while (m < G.get(t).size()) {
					String s = "";
					s += G.get(t).get(m).charAt(G.get(t).get(m).length() - 1);
					if (Vn.contains(s) && !L.contains(s)) {
						L.add(s);
					}
					m++;
				}
				count++;
			}
			// System.out.println(L);
			int m = 0;
			while (m < L.size()) {
				int t = Vn.indexOf(L.get(m));
				VnLastVT.get(i).addAll(VnLastVT.get(t));
				m++;
			}
			i++;
		}
		removeDuplicate(VnLastVT);// 清重复元素
		System.out.println("各非终结符的LASTVT集为：" + VnLastVT);

	}

	public static void VnAndVt(by02file bf) {// 整理文法中非终结符和终结符，由于扩展开始符E'，所以非终结符采用字符串存储
		String s0 = "";
		G = bf.PG();
		int i = 0;
		while (i < G.size()) {
			Vn.add(G.get(i).get(0));
			i++;
		}
		i = 0;
		while (i < G.size()) {
			int j = 1;
			while (j < G.get(i).size()) {
				int t = 0;
				while (t < G.get(i).get(j).length()) {
					s0 = "";
					s0 += G.get(i).get(j).charAt(t);
					if (!Vn.contains(s0) && !Vt.contains(G.get(i).get(j).charAt(t))) {
						Vt.add(G.get(i).get(j).charAt(t));
					}
					t++;
				}
				j++;
			}
			i++;
		}

	}

	public static char[][] Table() {
		N = Vt.size() + 1;
		char[][] c = new char[N][N];
		for (int i = 1; i < N; i++) {
			c[i][0] = (char) Vt.get(i - 1);
			c[0][i] = (char) Vt.get(i - 1);
		}
		int i = 0;
		int j;
		while (i < G.size()) {
			j = 1;
			while (j < G.get(i).size()) {
				for (int t = 0; t < G.get(i).get(j).length(); t++) {
					if (Vt.contains(G.get(i).get(j).charAt(t))) {// 遍历到终结符
						if (t - 1 >= 0 && !Vt.contains(G.get(i).get(j).charAt(t - 1))) {
							// 判其前是否有非终结符，若有将其LastVT集中元素>此终结符,L中元素>此元素
							String s = "";
							s += G.get(i).get(j).charAt(t - 1);
							int x = Vn.indexOf(s);
							for (int y = 0; y < VnLastVT.get(x).size(); y++) {
								c[Vt.indexOf(VnLastVT.get(x).get(y)) + 1][Vt.indexOf(G.get(i).get(j).charAt(t))
										+ 1] = '>';
							}
						}
						if (t + 1 < G.get(i).get(j).length() && !Vt.contains(G.get(i).get(j).charAt(t + 1))) {
							// 判其后是否有非终结符，若有将其FirstVT集中元素<此终结符，此元素<F中元素
							String s = "";
							s += G.get(i).get(j).charAt(t + 1);
							int x = Vn.indexOf(s);
							for (int y = 0; y < VnFirstVT.get(x).size(); y++) {
								c[Vt.indexOf(G.get(i).get(j).charAt(t)) + 1][Vt.indexOf(VnFirstVT.get(x).get(y))
										+ 1] = '<';
							}
							if (t + 2 < G.get(i).get(j).length() && Vt.contains(G.get(i).get(j).charAt(t + 2))) {
								c[Vt.indexOf(G.get(i).get(j).charAt(t)) + 1][Vt.indexOf(G.get(i).get(j).charAt(t + 2))
										+ 1] = '=';
							}
						} else if (t + 1 < G.get(i).get(j).length() && Vt.contains(G.get(i).get(j).charAt(t + 1))) {
							c[Vt.indexOf(G.get(i).get(j).charAt(t)) + 1][Vt.indexOf(G.get(i).get(j).charAt(t + 1))
									+ 1] = '=';
						}

					}
				}
				j++;
			}
			i++;
		}
		for (i = 0; i < N; i++) {
			for (j = 0; j < N; j++) {
				System.out.print(c[i][j]);
				System.out.print('\t');
			}
			System.out.println();
			System.out.println();
		}

		return c;
	}

	public static String DataReduction(String s, String s0) {
		int i = 0;
		while (i < s.length()) {
			if (Vt.contains(s.charAt(i))) {
				String ss = "";
				ss += s.charAt(i);
				int x = 0;
				while (x < G.size()) {
					int j = 1;
					while (j < G.get(x).size()) {
						if (G.get(x).get(j).contains(ss)) {
							s0 = s0.replace(s, G.get(x).get(0));
							return s0;
						}
						j++;
					}
					x++;
				}
			}
			i++;
		}
		return s0;

	}

	public static void analysis(char[][] c, String s) {
		String s0 = "#";// 入栈字符
		String s1 = "";// 临时字符串
		int j = 0;// j最后一个终结符在栈中位置，i为输入串当前扫描位置
		int i = 1;
		do {
			if (Vt.contains(s.charAt(i))) {
				if (c[Vt.indexOf(s0.charAt(j)) + 1][Vt.indexOf(s.charAt(i)) + 1] == '>') {
					s1 = "";
					// 从当前位置往前找<
					if (j != s0.length() - 1) {
						s1 = s0.charAt(s0.length() - 1) + s1;
					}
					s1 = s0.charAt(j) + s1;

					while (j > 0) {

						if (Vt.contains(s0.charAt(j - 1))) {

							if (c[Vt.indexOf(s0.charAt(j - 1)) + 1][Vt.indexOf(s0.charAt(j)) + 1] == '<') {
								// s1为将要归约的字符串

								s0 = DataReduction(s1, s0);
								if (s0 == "") {
									return;
								}
								j = s0.length() - 1;
								while (!Vt.contains(s0.charAt(j))) {
									j--;

								}
								System.out.println("规约\t栈中\t" + s0);

								i--;
								break;
							} else {
								s1 = s0.charAt(j - 1) + s1;
								j--;
								continue;
							}
						} else {
							s1 = s0.charAt(j - 1) + s1;
							if (j - 2 >= 0 && Vt.contains(s0.charAt(j - 2))) {
								if (c[Vt.indexOf(s0.charAt(j - 2)) + 1][Vt.indexOf(s0.charAt(j)) + 1] == '<') {
									// s1为将要归约的字符串
									s0 = DataReduction(s1, s0);
									if (s0 == "") {
										return;
									}
									j = s0.length() - 1;
									while (!Vt.contains(s0.charAt(j))) {
										j--;
									}
									System.out.println("规约\t栈中\t" + s0);
									i--;
									break;
								} else {
									s1 = s0.charAt(j - 2) + s1;
									j -= 2;
									continue;
								}
							} else
								System.out.println("error!");
						}

					}
				} else if (c[Vt.indexOf(s0.charAt(j)) + 1][Vt.indexOf(s.charAt(i)) + 1] == '<'
						|| c[Vt.indexOf(s0.charAt(j)) + 1][Vt.indexOf(s.charAt(i)) + 1] == '=') {
					s0 += s.charAt(i);
					System.out.println("移进\t栈中：\t" + s0);
					j = s0.length() - 1;
				} else {
					System.out.println("error!");
					return;
				}

			} else {
				s0 += s.charAt(i);
				System.out.println("移进\t栈中：\t" + s0);

			}
			i++;
		} while (s.charAt(i - 1) != '#');
		if (s0.length() == 3) {
			System.out.println("接受");
		}

	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		by02file bf = new by02file();
		bf.getStr();
		VnAndVt(bf);
		System.out.println("文法非终结符:" + Vn);

		System.out.println("文法终结符:" + Vt);
		FirstVT();
		LastVT();
		N = Vt.size() + 1;
		char[][] c = new char[N][N];
		c = Table();
		
		Scanner sc = new Scanner(System.in);
		String s = sc.nextLine();
		s = "#" + s + "#";
		analysis(c, s);

//		System.out.println(Vn);
	}

}
阿今呀
关注
专栏目录
编译原理：算符优先分析法
jianbai_的博客
05-28 8951
编译原理：算符优先分析文法
编译原理之算符优先分析
热门推荐
Welkin_qing的博客
06-20 1万+
文章目录一. 什么是算符文法？应满足什么条件二. 算符文法中，相邻算符之间的优先关系有几种？如何定义？三. 如何构造优先关系矩阵？1. FIRSTVT集、LASTVT集的定义及构造方法；2. 构造优先关系矩阵的算法？举例加以讲解；四. 算符优先分析法最左规约串的确定1. 最左素短语的定义是什么？2. 最左素短语的特征？如何根据其特征确定当前句型的最左可归约串？3. 什么是“单非产生式”，算符优...
编译原理：算符优先分析
燕双嘤
04-24 1万+
算符优先分析过程是自上而下的归约过程，但未必是严格的最左归约。也就是说，算符优先分析法不是一种规范归约法。所谓【算符优先分析法】就是定义算符之间的某种优先关系，借助于这种关系寻找“可归约串”进行归约的一种方法。【算符文法】一个文法，如果它的任一产生式的右部都不含两个相继（并列）的非终结符，即不含如下形式的产生式右部： ，则我们称该文法为算符文法。
28-C++-运算符优先级
青木年华
06-03 5152
补充内容：运算符优先级运算符优先级决定了运算符对于值的顺序。C++运算符分为18个优先级组，如下表所示。第一组的运算符的优先级就搞，第二组中运算符的优先级次之，以此类推。如果两个运算符被用于同一个操作数，则首先应用优先级搞得运算符。如果两个运算符的优先级相同，则C++使用结合性规则来决定哪个运算符结合得更为紧密。同一组中运算符的优先级和结合性相同。不管是从左到右还是从右到左结合，从左到右的结合性意...
算符优先语法分析程序
07-07
实现算符优先分析算法，完成以下描述算术表达式的算符优先文法的算符优先分析过程。 G[E]:E→E+T∣E-T∣T T→T*F∣T/F∣F F→(E)∣i 说明：终结符号i为用户定义的简单变量,即标识符的定义。 要求： （1）构造该算符优先文法的优先关系矩阵或优先函数； （2）输入串应是词法分析的输出二元式序列，即某算术表达式“实验项目一”的输出结果。输出为输入串是否为该文法定义的算术表达式的判断结果。 （3）算符优先分析过程应能发现输入串出错。 （4）设计两个测试用例（尽可能完备），并给出测试结果。
编译原理实验二——算符优先分析法设计与实现
08-29
算符优先分析法是一种常用的语法分析方法，用于解决编译器的语法分析阶段问题。本实验旨在通过实际操作加深学生对算符优先分析法的理解，并提高程序设计能力。 【实验内容与步骤】 1. **定义目标语言的语法规则**...
实验三 算符优先分析算法的设计与实现.doc
03-11
实验三 算符优先分析算法的设计与实现 在编译原理领域中，算符优先分析算法是一种重要的语法分析方法，本实验的目的是设计和实现算符优先分析算法，以判断一个表达式是否正确。 一、 实验目的 本实验的目的是通过...
算符优先文法处理判断算术表达式的正确性
06-13
算符优先文法是编译原理中的一种解析技术，它用于处理和解析算术表达式，以确保其结构正确并能被准确地计算。本文将详细介绍算符优先文法在判断算术表达式正确性中的应用，并结合提供的源代码、说明文档和输入输出...
算符优先分析
10-23
### 知识点：算符优先分析 #### 一、算符优先分析的基本概念与应用场景 算符优先分析是编译原理中一种重要的语法分析方法，适用于上下文无关文法中的算术表达式分析。其核心思想是通过优先级表（优先关系矩阵）来...
编译原理实验——利用算符优先分析方法设计一个计算器
09-23
（Python实现，注释详细）直接输入：3+4*5，一般的...(1)第一阶段，运用算符优先分析算法完成计算器中对算术表达式的语法分析； (2)第二阶段，设计属性文法，改造第一阶段的程序，完成算术表达式的计算和相关的输出。
算符优先文法分析器的设计与实现(java gui 版)
07-05
1． 设计扫描程序，将任何一种整数运算表达式（无变量，操作数为正整数，允许加减乘除四种运算，允许使用括号和多层括号）识别为单词，并能发现单词的拼写错误 2． 设计自底向上分析程序，在栈上实现对单词token串的自底向上分析 3． 根据算符优先文法的分析步骤，展示分析栈、token串的状态变化、相关量的优先级比较(算符优先分析表)结果输出 、判断当前是否进行规约或移进操作、（若须规约）显示当前应规约的串 4． 展示语法树
java版语法分析程序
11-15
java版 语法分析程序 树结构 swing
算符优先语法分析设计原理与实现技术
07-08
实现算符优先分析算法，完成以下描述算术表达式的算符优先文法的算符优先分析过程。 G[E]:E→E+T∣E-T∣ T→T*F∣T/F∣F F→(E)∣i 说明：终结符号i为用户定义的简单变量,即标识符的定义。
算符优先分析法
05-22
设有文法G[S]：S→SaF | F F→FbP | P P→c | d (1) 构造G[S]的算符优先关系表 (2) 分别给出cadbdac# 和 dbcabc# 的分析过程
编译原理课程设计-LL(1)预测分析法 算符优先分析 LR分析
06-29
一 课程设计的目的 - 2 - 二 课程设计的内容及要求 - 2 - 2.1 课程设计内容 - 2 - 2.2 课程设计要求 - 2 - 三 实现原理 - 2 - 3.1、词法分析 - 2 - 3.2、语法分析 - 3 - 语法分析程序可以根据个人的掌握情况选用常见的几种语法分析方法：递归下降分析方法、LL(1)预测分析法、算符优先分析、LR分析等方法中的任何一种来实现，也可以选用不同的方法来分析不同的语法成分，最后再综合起来。这里做了算符优先分析和LR(0)分析演示。 - 4 - 3.3、语义分析 - 4 - 四 算法实现流程图 - 5 - 4.1. 词法分析算法 - 5 - 4.2. 语法分析算法思想 - 7 - 语法分析流程图 - 7 - 算符优先分析流程图 - 8 - LR（0）预测分析流程图 - 8 - 五 测试数据 - 9 - 5.1词法分析测试数据 - 9 - 5.2 词法分析三个算法测试数据 - 10 - 5.3语法分析三个算法测试数据 - 10 - 5.4 语义分析测试数据 - 10 - 六 结果输出及分析 - 10 - 6.1语法分析阶段截图 - 11 - 6.2 语法分析两个算法截图 - 14 - 6.3语义分析阶段截图 - 15 - 七．软件运行环境及限制 - 15 - 八．心得体会 - 16 - 九．参考文献 - 16 -
4.4 算 符 优 先 分 析 法
qq_45180475的博客
08-07 4434
4.4 算 符 优 先 分 析 法 4.4.1 方法概述 所谓算符优先分析法就是依照算术表达式的四则运算过程而设计的一种语法分析方法。 这种分析方法首先要规定运算符之间(确切地说是终结符之间)的优先关系和结合性质,然后借助这种关系,比较相邻运算符的优先级来确定句型的可归约串并进行归约。 下面,以表达式的文法为例,说明采用这种分析法分析符号串 id + id * id 的分析过程。 例如,文法 G [ E ]为 E → E + E | E * E | ( E ) | id 这个文法是一个二义性文法,因而对
数据结构学习笔记三：算符优先算法
weixin_30782293的博客
08-11 425
给出一个表达式 2*(3-1),迅雷不及掩耳，立马知道答案为4，但是计算机可没有这样的能耐，它只知道直接计算，却不知道优先级。如此，我们需要自己用代码来告诉它算符的优先级 从左至右 先乘除后加减 先括号内后括号外 先来研究简单的算术表达式，只有+-*/（）运算符 算符优先表如上图，其中#为结束标识符。 现在来纠结具体的实现。 /// <summary&gt...
算符优先算法实现
xurui1073337662的博客
06-23 2506
实现算符优先算法，完成一个算符优先文法的算法优先分析过程。(1)根据给定文法,先求出FirstVt和LastVt集合,构造算符优先关系表(要求算符优先关系表输出到屏幕或者输出到文件);(2)根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式(要求输出归约过程)(3)给定表达式文法为:G(E’): E’→#E#E→E+T | TT→T*F |FF→(E)|i(4)分析的句子为:...
java实现算符优先文法ll1文法
weixin_41705703的博客
06-04 2078
实验要求： 1.[实验项目] 实现LL(1)分析中控制程序（表驱动程序）；完成以下描述赋值语句的LL(1)文法的LL(1)分析过程。 G[E]: E →E+T∣E-T∣T T→T*F∣T/F∣F F→(E)∣i 2.[设计说明] 终结符号i 为用户定义的简单变量,即标识符的定义。 3.[设计要求] （1）构造该算符优先文法的优先关系矩阵或优先函数； （2）输入串应是词法分析的输出二元式序列，即某算...
算符优先分析器实现代码
"本文将介绍算符优先分析在编译原理中的应用，通过提供的部分代码展示了实现算符优先分析器的对话框类`CAboutDlg`的定义和数据交换功能。" 算符优先分析是一种在编译器设计中用于解析语法的算法，它基于算符的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值