郑州大学编译原理实验三算符优先分析算法JAVA

最新推荐文章于 2024-04-27 11:13:02 发布
最新推荐文章于 2024-04-27 11:13:02 发布
阅读量1.6w 收藏 8
点赞数 1
分类专栏： 编译原理实验 文章标签： 算法 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54884881/article/details/127696087
版权

一、 实验目的

根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式是否正确。通过算符优先分析方法的实现，加深对自下而上语法分析方法的理解。

二、 实验内容

1、输入文法。可以是如下算术表达式的文法（你可以根据需要适当改变）：
E→E+T|E-T|T
T→T*F|T/F|F
F→（E）|i

2、对给定表达式进行分析，输出表达式正确与否的判断。
程序输入/输出示例：
输入：1+2;
输出：正确
输入：(1+2)/3+4-(5+6/7);
输出：正确
输入：((1-2)/3+4
输出：错误
输入：1+2-3+(*4/5)
输出：错误

3、参考数据结构
char *VN=0,*VT=0;//非终结符和终结符数组
char firstvt[N][N],lastvt[N][N],table[N][N];
typedef struct //符号对(P,a)
{
char Vn;
char Vt;
} VN_VT;
typedef struct //栈
{
VN_VT *top;
VN_VT *bollow;
int size;
}stack;

4、根据文法求FIRSTVT集和LASTVT集

5、构造算符优先分析表

6、构造总控程序

7、对给定的表达式，给出准确与否的分析过程
8、给出表达式的计算结果。（本步骤可选作）

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.*;

/**
 * @author [25'h]
 * @datetime 2022.11.02
 */
public class Reducing {
    public static String startLabel;//开始符
    public static ArrayList<String> terSymbol = new ArrayList<>();// 终结符
    public static ArrayList<String> non_ter = new ArrayList<>();// 非终结符
    public static HashMap<String, List<String>> formula = new HashMap<>();//产生式
    public static HashMap<String, Set<String>[]> firstvtAndLastvt = new HashMap<>();//FIRST  和  FOLLOW
    /*
        firstvtAndLastvt的数据含义：
            - key : 非终结符
            - value : 非终结符对应的FIRSTVT  和  FOLLOWVT 集
                - 1     非终结符对应的FIRSTVT
                - 2     非终结符对应的FOLLOWVT
    */
    public static boolean[] booleansFirst;// 辅助变量
    public static boolean[] booleansLast;
    public static String[][] table;//优先表
    public static String objString;// 目标匹配字符串

    public static LinkedList<String> deque;

    public static void main(String[] args) {
        File file = new File("src/StringToJAVA/test3.txt");
        BufferedReader bufferedReader;
        try {
            // 读取文法和目标式子
            bufferedReader = new BufferedReader(new FileReader(file));
            startLabel = bufferedReader.readLine();
            // 读取非终结符
            non_ter.addAll(Arrays.asList(bufferedReader.readLine().split(" ")));
            booleansFirst = new boolean[non_ter.size()];// 初始化辅助变量
            booleansLast = new boolean[non_ter.size()];
            // 初始化firstAndFollow中的Map对象
            for (String s : non_ter) {
                firstvtAndLastvt.put(s, new HashSet[]{new HashSet(), new HashSet()});
            }
            // 读取终结符
            terSymbol.addAll(Arrays.asList(bufferedReader.readLine().split(" ")));
            table = new String[terSymbol.size() + 1][terSymbol.size() + 1];
            //将产生式右部或表达式分离
            String s;
            while ((s = bufferedReader.readLine()).contains("->")) {
                String[] split = s.split("->");
                formula.put(split[0], Arrays.asList(split[1].split("\\|")));
            }
            // 赋值目标串
            objString = s;
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 生成firstvt和lastvt
        generateFirstVTAndLastVT();
        // 生成优先分析表
        generateTable();
        // 归约
        reducing();
        show();
    }

    private static void reducing() {
        // 终结符中添加结尾符号
        terSymbol.add("#");
        deque = new LinkedList<>();
        deque.push("#");
        for (int i = 0; i < objString.length(); i++) {
            // 取出下一个字符
            String sub = objString.substring(i, i + 1);
            if (terSymbol.contains(sub)) {// 是终结符
                // 栈最上面的终结符是temp
                String temp = terSymbol.contains(deque.peek()) ? deque.peek() : deque.get(1);
                // 看看跟上一个终结符和sub大优先级关系
                String bol = table[terSymbol.indexOf(temp)][terSymbol.indexOf(sub)];
                // 是> 就归约
                if (bol.equals(">")) {
                    func(sub);
                }
                // 归约后终结符入栈
            }
            deque.push(sub);// 直接压入
            showCurStack(i);
        }
    }

    //输出当前的栈状态
    private static void showCurStack(int i) {
        StringBuffer b = new StringBuffer();
        for (int j = deque.size() - 1; j >= 0; j--) {
            b = b.append(deque.get(j));
        }
        if (i != objString.length() - 1)
            b = b.append("\t\t\t").append(objString.substring(i + 1));
        System.out.println(b.toString());
    }


    private static void func(String curTer) {
        String te;
        // 栈顶非终结符读出
        if (!terSymbol.contains(deque.peek())) {
            deque.pop();
        }
        do {
            te = deque.pop();// 当前规约串的终结符te
// te左的非终结符
            if (!terSymbol.contains(deque.peek())) {
                deque.pop();
            }
        } while (!table[terSymbol.indexOf(deque.peek())][terSymbol.indexOf(te)].equals("<"));
        // 栈顶终结符
        te = deque.peek();
        deque.push("N");// 标记
        // 若还是>,则递归调用
        if (table[terSymbol.indexOf(te)][terSymbol.indexOf(curTer)].equals(">")) {
            func(curTer);
        }
    }

    private static void generateTable() {
        // 对于每个公式都要取出终结符
        for (String non : formula.keySet()) {
            List<String> list = formula.get(non);//non这个非终结符对应的生成式
            for (String f : list) {// 对于每个式子f
                ArrayList<String> li = new ArrayList<>();// 每个式子的终结符记下来，因为他们之间的关系是=
                // 对式子f要查找终结符位置
                for (int i = 0; i < f.length(); i++) {
                    // 对于f中每个元素sub
                    String sub = f.substring(i, i + 1);
                    // 若是终结符
                    if (terSymbol.contains(sub)) {
                        li.add(sub);//几下终结符
                        // 左边有非终结符
                        if (i != 0 && non_ter.contains(f.substring(i - 1, i))) {
                            //赋值“>”
                            pre(f.substring(i - 1, i), sub);
                        }
                        //右边有非终结符
                        if (i != f.length() - 1 && non_ter.contains(f.substring(i + 1, i + 2))) {
                            //赋值“<”
                            post(f.substring(i + 1, i + 2), sub);
                        }
                    }
                }
                // 想等情况赋值，注意是 j = i + 1
                for (int i = 0; i < li.size(); i++) {
                    for (int j = i + 1; j < li.size(); j++) {
                        table[terSymbol.indexOf(li.get(i))][terSymbol.indexOf(li.get(j))] = "=";
                    }
                }
            }
        }
        // 关于#的赋值
        Set<String>[] sets = firstvtAndLastvt.get(startLabel);
        for (String s : sets[0]) {
            table[terSymbol.size()][terSymbol.indexOf(s)] = "<";
        }
        for (String s : sets[1]) {
            table[terSymbol.indexOf(s)][terSymbol.size()] = ">";
        }
        table[terSymbol.size()][terSymbol.size()] = "=";

    }

    private static void post(String non, String ter) {
        int index = terSymbol.indexOf(ter);
        Set<String> set = firstvtAndLastvt.get(non)[0];
        for (String s : set) {
            table[index][terSymbol.indexOf(s)] = "<";
        }
    }

    private static void pre(String non, String ter) {
        int index = terSymbol.indexOf(ter);
        Set<String> set = firstvtAndLastvt.get(non)[1];
        for (String s : set) {
            table[terSymbol.indexOf(s)][index] = ">";
        }
    }

    //生成firstvt和lastvt
    private static void generateFirstVTAndLastVT() {
        for (String s : non_ter) {
            if (!booleansFirst[non_ter.indexOf(s)])
                generateEachFirstVT(s);
            if (!booleansLast[non_ter.indexOf(s)]) {
                generateEachLastVT(s);
            }
        }
    }

    /*
    生成每个非终结符non的Lastvt集
     */
    private static void generateEachLastVT(String non) {
        Set<String> curList = firstvtAndLastvt.get(non)[1];
        for (String s : formula.get(non)) {
            // lastvt本质就是firstvt反过来的求法
            modify(non, curList, new StringBuffer(s).reverse().toString(), 1);
        }
        booleansLast[non_ter.indexOf(non)] = true;
    }

    /*
    生成每个非终结符non的Firstvt集
     */
    private static void generateEachFirstVT(String terNon) {
        Set<String> curList = firstvtAndLastvt.get(terNon)[0];
        for (String s : formula.get(terNon)) {
            modify(terNon, curList, s, 0);
        }
        booleansFirst[non_ter.indexOf(terNon)] = true;
    }


    private static void modify(String non, Set<String> curList, String s, int i) {
        String firstSub = s.substring(0, 1);
        if (terSymbol.contains(firstSub)) {// 终结符开头
            curList.add(firstSub);
        } else {// 非终结符开头
            // 终结符是第二个位置
            if (s.length() >= 2 && terSymbol.contains(s.substring(1, 2))) {
                curList.add(s.substring(1, 2));
            }
            // firstSub和non相同，避免栈溢出返回
            if (firstSub.equals(non)) return;
            if (i == 0) {// 求firstvt，用booleansFirst
                if (!booleansFirst[non_ter.indexOf(firstSub)]) {
                    generateEachFirstVT(firstSub);
                }
            } else {// 求lastvt，booleansLast
                if (!booleansLast[non_ter.indexOf(firstSub)]) {
                    generateEachLastVT(firstSub);
                }
            }
            curList.addAll(firstvtAndLastvt.get(firstSub)[i]);

        }
    }

    private static void show() {
        System.out.println(startLabel);
        System.out.println(Arrays.toString(non_ter.toArray()));
        System.out.println(Arrays.toString(terSymbol.toArray()));
        for (String s : formula.keySet()) {
            System.out.println(s + "\t" + Arrays.toString(formula.get(s).toArray()));
        }
        System.out.println();
        for (String s : firstvtAndLastvt.keySet()) {
            System.out.println(s + "\t" + Arrays.toString(firstvtAndLastvt.get(s)[0].toArray()) + "\t" + Arrays.toString(firstvtAndLastvt.get(s)[1].toArray()));
        }
        System.out.println();
        for (String[] strings : table) {
            System.out.println(Arrays.toString(strings));
        }
    }

}

test3.txt文件：

E
E T F
i * / + - ( )
E->E+T|E-T|T
T->T*F|T/F|F
F->(E)|i
(1+2)/3+4-(5+6/7)#

输出结果：

"D:\Program Files\Java\jdk1.8.0_291\bin\java.exe" "-javaagent:D:\IntelliJ IDEA 2020.1\lib\idea_rt.jar=54769:D:\IntelliJ IDEA 2020.1\bin" -Dfile.encoding=UTF-8 -classpath "D:\Program Files\Java\jdk1.8.0_291\jre\lib\charsets.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\deploy.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\access-bridge-64.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\cldrdata.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\dnsns.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jaccess.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\jfxrt.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\localedata.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\nashorn.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunec.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunjce_provider.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunmscapi.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\sunpkcs11.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\ext\zipfs.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\javaws.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\jce.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\jfr.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\jfxswt.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\jsse.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\management-agent.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\plugin.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\resources.jar;D:\Program Files\Java\jdk1.8.0_291\jre\lib\rt.jar;D:\code_management\algorithm\out\production\algorithm" StringToJAVA.Reducing
#(			1+2)/3+4-(5+6/7)#
#(1			+2)/3+4-(5+6/7)#
#(1+			2)/3+4-(5+6/7)#
#(1+2			)/3+4-(5+6/7)#
#(N)			/3+4-(5+6/7)#
#N/			3+4-(5+6/7)#
#N/3			+4-(5+6/7)#
#N+			4-(5+6/7)#
#N+4			-(5+6/7)#
#N-			(5+6/7)#
#N-(			5+6/7)#
#N-(5			+6/7)#
#N-(5+			6/7)#
#N-(5+6			/7)#
#N-(5+6/			7)#
#N-(5+6/7			)#
#N-(N)			#
#N#
E
[E, T, F]
[i, *, /, +, -, (, ), #]
T	[T*F, T/F, F]
E	[E+T, E-T, T]
F	[(E), i]

T	[(, i, *, /]	[), i, *, /]
E	[(, i, *, +, -, /]	[), i, *, +, -, /]
F	[(, i]	[), i]

[null, >, >, >, >, null, >, >]
[<, >, >, >, >, <, >, >]
[<, >, >, >, >, <, >, >]
[<, <, <, >, >, <, >, >]
[<, <, <, >, >, <, >, >]
[<, <, <, <, <, <, =, null]
[null, >, >, >, >, null, >, >]
[<, <, <, <, <, <, null, =]

Process finished with exit code 0
「 25' h 」
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
郑州大学java实验报告
05-31
郑州大学java实验报告
郑州大学软件学院机试题java方向各种机试题及答案
01-22
郑州大学软件学院机试题java方向各种机试题 数据结构 组成原理 jsp 计算机网络等上机考试原题及答案
编译原理实验二——算符优先分析法设计与实现
08-29
用算符优先分析方法设计一个分析解释程序，对输入的赋值语句、输出语句、清除语句进行词法分析、语法分析、表达式求值并存储于指定变量中；若存在错误，提示错误相关信息。
java实验报告
11-19
有关java封装技术的实验，适合初学者练习，主要讲了封装技术的用法，附带有例子。
java以下声明变量中 是不合法的_JAVA程序设计导论模拟考卷
weixin_39985820的博客
02-13 528
郑州大学软件学院《程序设计导论Java 》课程试题(模拟卷)(适用专业： 考试时间：120分钟)合分人： 一、单项选择：(每题2分，共40分)1、在Java 中，main()方法的返回值的类型是：cA 、publicB 、staticC 、voidD 、String 2、Java 源程序文件的扩展名为：aA 、.javaB 、.classC 、.exeD 、.jar 3、在JAVA 中，下列标识符...
词法分析器
ZZU_DF的专栏
05-11 2653
实验一  源程序的预处理及词法分析程序设计 （6学时） 一、 实验目的 设计并实现一个包含预处理功能的词法分析程序，加深对编译中词法分析过程的理解。 二、 实验要求 1、实现预处理功能 源程序中可能包含有对程序执行无意义的符号，要求将其剔除。 首先编制一个源程序的输入过程，从键盘、文件或文本框输入若干行语句，依次存入输入缓冲区（字符型数据）；然后编制一个预处理子程序，去掉输入串中的回
编译原理：算符优先分析实验
Believer_YU的博客
07-13 3623
编译原理实验，实现算符优先分析，输入一个文法，判断是否是算符优先文法，是则构造优先表，输入待分析串，输出分析过程。
[编译原理] 算符优先分析实验报告
nebois的博客
05-24 976
算符优先分析法的基本思想是，为每个运算符赋予一个优先级，然后利用这些优先级来确定运算符之间的顺序。在算符优先分析法中，每个运算符都有一个左优先级和一个右优先级，用来指示它在与相邻运算符结合时的优先级。通常，左结合性指示运算符与其左边的运算符结合，右结合性指示运算符与其右边的运算符结合。算符优先分析法的优点是简单而高效，特别适用于具有相对简单运算符优先级关系的表达式。然而，对于包含复杂优先级规则的表达式，算符优先分析法可能无法适应，需要使用其他更复杂的语法分析方法。3.实验算法及流程图。
编译原理实验：自下而上的语法分析---(算符优先分析)
拾灬Tao的博客
06-08 4351
** 算符优先分析程序(NCWU慎用) ** 1．实验要求 ⑴ 选择算符优先分析方法； ⑵ 选择对各种常见程序语言都用的语法结构，如赋值语句或表达式或控制流语句等作为分析对象，并且与所选语法分析方法要比较贴切。 ⑶ 实验时间为6学时。 2．实验内容及要求 （1）根据给定文法，先求出FirstVt和LastVt集合，构造算符优先关系表（要求算符优先关系表 输出到显示器或者输出到文件）； （2）根据算法和优先关系表分析给定表达式是否是该文法识别的正确的算术表达式（要求输出归约过程） （3）假如给定表达式文
编译原理实验算符优先算法
05-07
编译原理课程实验报告，附加源代码，给力哦！
编译原理课程设计---java实现算符优先分析法
04-26
编译原理课程设计---java实现算符优先分析法
实验三 算符优先分析算法的设计与实现.doc
03-11
实验三 算符优先分析算法的设计与实现.doc
编译原理实验——利用算符优先分析方法设计一个计算器
09-23
（Python实现，注释详细）直接输入：3+4*5，一般的...(1)第一阶段，运用算符优先分析算法完成计算器中对算术表达式的语法分析； (2)第二阶段，设计属性文法，改造第一阶段的程序，完成算术表达式的计算和相关的输出。
编译原理课程设计 算符优先文法 带界面 Java版
07-29
算符优先文法完整版，程序实现了几乎整个算符优先文法的自动化分析，并且展示到GUI界面上，可由用户输入任何文法和输入串，算符优先文法则正常分析，非算符优先文法则提示错误信息，并且整个程序在一些方面设计了...
代码随想录算法训练营day53
最新发布
Mitakiyuki的博客
04-27 239
从前到后遍历。
算法训练营day21
wugong_true的博客
04-23 395
接下来，根据计数count与最大计数maxCount的比较，更新众数的结果数组resList和最大计数maxCount。如果count大于maxCount，则清空resList并将当前节点值添加进去，并更新maxCount为count；接着，根据resList中的众数，创建一个整型数组res，并将其返回作为结果。然后，通过与前一个节点的值进行比较，判断当前节点值出现的次数。如果当前节点与前一个节点的值不同，说明出现了一个新的值，将计数count重置为1；，计算相邻两个元素的差值，并将较小的差值更新到。
排序算法-快速排序
分享我的点点滴滴，在成长路上与你同行！
04-23 1077
排序算法-快速排序
【错题集-编程题】数组中的最长连续子序列（排序 + 模拟）
Elena's Blog
04-24 295
因为题目不要求位置连续，那么就可以直接想到排序（我把这一块理解错了，导致没有排序去做），接着就是简单的模拟。，然而实际上这道题目要求的是。小心处理数字相同的情况。
代码随想录算法训练营day40
weixin_43390031的博客
04-23 399
1为头，左子树节点个数为0，右子数节点个数为2，即dp[0]*dp[2]，2为头，dp[1]*dp[1]，3为头dp[2]*dp[0]。故对dp[i]，我们也考虑1到i为头节点的数量相加，dp[i]=dp[0]*dp[i-1]+dp[1]*dp[i-2]+…时间复杂度O(n^2)。(i-2)取最大值，综合讨论一下就是拆成i-j和j，然后比较dp[i-j]*j和(i-j)*j的最大值，这里因为dp[i-j]必须要进行至少拆成两个数，所以没有包含i-j，故我们还需要比较i-j，递推公式就是。
编译原理实验算符优先分析算法
12-02
算符优先分析法是一种自下而上的语法分析方法，它可以用于分析和处理算术表达式、布尔表达式等。下面是算符优先分析法的实现步骤： 1. 定义终结符和非终结符：终结符是指不能再分解的基本符号，如数字、运算符等；...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

「 25' h 」

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值