预测分析算法的设计与实现

最新推荐文章于 2024-01-23 10:47:07 发布
最新推荐文章于 2024-01-23 10:47:07 发布
阅读量90 收藏
点赞数
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c18338457215/article/details/134464067
版权

实验代码

Main 类

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        LL1Parser ll1Parser = new LL1Parser();
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入要分析的句子：");
        String sentence = scanner.nextLine();
        ll1Parser.analyze(sentence);
        ll1Parser.printLL1Parser();
    }
}

LL1parser类

import java.util.*;

public class LL1Parser {
    private char START_SYMBOL;
    private Map<Character, List<String>> grammar;
    private Map<Character, Set<Character>> first;
    private Map<Character, Set<Character>> follow;
    private Set<Character> VT;
    private Map<Character, Map<Character, String>> ll1Table;

    public LL1Parser() {
        initGrammar();
    }

    private void initGrammar() {
        getGrammar();
        calculateFirst();
        calculateFollow();
        calculateLL1Table();
    }

    private void getGrammar() {
        this.grammar = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入文法数量以及文法开始符号，然后按照 A->**|** 格式输入文法");

        // 读取文法数量以及开始符号
        String string = sc.nextLine();
        String[] splits = string.split(" ");
        int count = Integer.parseInt(splits[0]);
        START_SYMBOL = splits[1].charAt(0);

        for (int i = 0; i < count; i++) {
            String line = sc.nextLine();
            String[] split = line.substring(3).split("\\|");
            this.grammar.put(line.charAt(0), Arrays.asList(split));
        }
    }

    private void calculateFirst() {
        this.first = new HashMap<>();
        for (char key : this.grammar.keySet()) {
            List<String> production = grammar.get(key);
            this.first.put(key, new HashSet<>());

            for (String value : production) {
                if (!Character.isUpperCase(value.charAt(0))) { // 不是非终结符
                    this.first.get(key).add(value.charAt(0));
                }
            }

        }

        for (int i = 0; i < 2; i++) {
            for (char key : this.grammar.keySet()) {
                List<String> production = grammar.get(key);

                for (String value : production) {
                    if (Character.isUpperCase(value.charAt(0))) { // 不是非终结符
                        this.first.get(key).addAll(this.first.get(value.charAt(0)));
                    }
                }

            }
        }


    }

    private void calculateFollow() {
        this.follow = new HashMap<>();

        // 为文法开始符添加#
        for (Character VN : grammar.keySet()) {
            this.follow.put(VN, new HashSet<>());
            if (VN == START_SYMBOL) {
                this.follow.get(VN).add('#');
            }
        }

        for (int i = 0; i < 3; i++) {
            for (Character VN : this.grammar.keySet()) {

                // 得到产生式
                List<String> productions = grammar.get(VN);
                for (String production : productions) {
                    char lastChar = production.charAt(production.length() - 1);

                    // S->αA，将 S 的 Follow 集加到 A 的 Follow 集中
                    if (Character.isUpperCase(lastChar)) {
                        follow.get(lastChar).addAll(this.follow.get(VN));
                    }


                    for (int j = 0; j < production.length() - 1; j++) {
                        if (Character.isUpperCase(production.charAt(j))) {
                            if (Character.isUpperCase(production.charAt(j + 1))) { // 若A→αBβ是一个产生式，则把FIRST(β)\{ε}加至FOLLOW(B)中
                                follow.get(production.charAt(j)).addAll(first.get(production.charAt(j + 1)));
                                follow.get(production.charAt(j)).remove('$'); // ε
                            } else if (production.charAt(j + 1) != '$') { // A->
                                follow.get(production.charAt(j)).add(production.charAt(j + 1));
                            }

                            boolean emptyFlag = true; // 用来判断是否含有 ε
                            for (int k = j + 1; k < production.length(); k++) {

                                // 后面的字符是终结符 或 是非终结符号但不含有ε
                                if (!Character.isUpperCase(production.charAt(k)) || (Character.isUpperCase(production.charAt(k)) && !first.get(production.charAt(k)).contains('$'))) {
                                    emptyFlag = false;
                                    break;
                                }
                            }
                            // 循环结束之后emptyFlag为真，表示当前字符后面的都是非终结符而且能推导出空串
                            if (emptyFlag) {
                                follow.get(production.charAt(j)).addAll(follow.get(VN));
                                follow.get(production.charAt(j)).remove('$');
                            }
                        }
                    }

                }
            }
        }

    }

    private void calculateVT() {
        VT = new HashSet<>();

        VT.add('#');
        for (List<String> productions : grammar.values()) {
            for (String production : productions) {
                for (char c : production.toCharArray()) {
                    if (!Character.isUpperCase(c) && c != '$') {
                        VT.add(c);
                    }
                }
            }
        }
    }

    private void calculateLL1Table() {
        ll1Table = new HashMap<>();
        calculateVT();

        // 初始化表格为空
        for (Character VN : grammar.keySet()) {
            ll1Table.put(VN, new HashMap<>());
            for (Character vt : VT) {
                ll1Table.get(VN).put(vt, null);
            }
        }

        for (Character VN : grammar.keySet()) {
            List<String> productions = grammar.get(VN);

            for (String production : productions) {
                if (Character.isUpperCase(production.charAt(0))) {
                    for (char vt : VT) {
                        if (first.get(production.charAt(0)).contains(vt)) {
                            ll1Table.get(VN).put(vt, production);
                        }
                    }
                } else {
                    if (production.charAt(0) != '$') {
                        ll1Table.get(VN).put(production.charAt(0), production);
                    } else {
                        for (char f : follow.get(VN)) {
                            ll1Table.get(VN).put(f, production);
                        }
                    }
                }
            }
        }
    }

    public void analyze(String sentence) {
        boolean flag = true;
        ArrayList<String[]> processList = new ArrayList<>();
        Stack<Character> stack = new Stack<>();
        stack.push('#');
        stack.push(this.START_SYMBOL);
        processList.add(new String[]{stack.toString(), sentence, ""});

        while (!stack.empty()) {
            char top = stack.peek();
            char input = sentence.charAt(0);
            if (VT.contains(top)) {
                if (top == input) {
                    sentence = sentence.substring(1);
                    stack.pop();
                    processList.add(new String[]{stack.toString(), sentence, ""});
                } else {
                    flag = false;
                    processList.add(new String[]{"error!!!"});
                    break;
                }
            } else {
                if (top == '#') {
                    if (top != input) {
                        flag = false;
                        processList.add(new String[]{"error!!!"});
                    }
                    break;
                } else {
                    String production = ll1Table.get(top).get(input);
                    if (production != null) {
                        stack.pop();
                        if (production.charAt(0) != '$') {
                            for (int i = production.length() - 1; i >= 0; i--) {
                                stack.push(production.charAt(i));
                            }
                        }
                        processList.add(new String[]{stack.toString(), sentence, top + "->" + production});
                    } else {
                        flag = false;
                        processList.add(new String[]{"error!!!", "", ""});
                        break;
                    }
                }
            }
        }
        System.out.println("分析过程：");
        // print processList
        for (int i = 0; i < processList.size(); i++) {
            System.out.printf("%d\t%-20s\t%15s\t%10s\n", i, processList.get(i)[0], processList.get(i)[1], processList.get(i)[2]);
        }

        if (flag) {
            System.out.println("句子符合文法规则");
        } else {
            System.out.println("句子不符合文法规则");
        }
    }


    // 打印LL1文法中的first集、follow集、预测分析表
    public void printLL1Parser() {

        System.out.println("文法为：");
        for (Map.Entry<Character, List<String>> characterListEntry : grammar.entrySet()) {
            List<String> value = characterListEntry.getValue();
            Character key = characterListEntry.getKey();
            String production = String.join("|", value);
            System.out.println(key + "->" + production);
        }

        System.out.println("first集为：");
        for (Map.Entry<Character, Set<Character>> firstEntrySet : first.entrySet()) {
            Character vn = firstEntrySet.getKey();
            Set<Character> firstValue = firstEntrySet.getValue();
            System.out.println(vn + "=" + firstValue);
        }

        System.out.println("follow集为：");
        for (Map.Entry<Character, Set<Character>> followEntrySet : follow.entrySet()) {
            Character vn = followEntrySet.getKey();
            Set<Character> followValue = followEntrySet.getValue();
            System.out.println(vn + "=" + followValue);
        }

        System.out.println("预测分析表为：");
        // 打印表头
        System.out.print(" \t|");
        for (Character vt : ll1Table.get(START_SYMBOL).keySet()) {
            System.out.printf("%-8s |", vt);
        }
        System.out.println();

        // 打印分隔线
        System.out.println("-----------------------------------------------------------------");

        // 打印每行的内容
        for (Character nonTerminal : ll1Table.keySet()) {
            System.out.print(nonTerminal + "\t|");
            Map<Character, String> row = ll1Table.get(nonTerminal);
            for (Character terminal : row.keySet()) {
                String production = nonTerminal + "->" + row.get(terminal);
                System.out.printf("%-8s |", production);
            }
            System.out.println();
        }

    }

}

测试用例

文法测试用例

5 S
S->QT
T->+QT|$
Q->VR
R->*VR|$
V->(S)|i

输入串测试用例

(i+i)*i#

运行结果

分析过程：
0	[#, S]              	       (i+i)*i#	          
1	[#, T, Q]           	       (i+i)*i#	     S->QT
2	[#, T, R, V]        	       (i+i)*i#	     Q->VR
3	[#, T, R, ), S, (]  	       (i+i)*i#	    V->(S)
4	[#, T, R, ), S]     	        i+i)*i#	          
5	[#, T, R, ), T, Q]  	        i+i)*i#	     S->QT
6	[#, T, R, ), T, R, V]	        i+i)*i#	     Q->VR
7	[#, T, R, ), T, R, i]	        i+i)*i#	      V->i
8	[#, T, R, ), T, R]  	         +i)*i#	          
9	[#, T, R, ), T]     	         +i)*i#	      R->$
10	[#, T, R, ), T, Q, +]	         +i)*i#	    T->+QT
11	[#, T, R, ), T, Q]  	          i)*i#	          
12	[#, T, R, ), T, R, V]	          i)*i#	     Q->VR
13	[#, T, R, ), T, R, i]	          i)*i#	      V->i
14	[#, T, R, ), T, R]  	           )*i#	          
15	[#, T, R, ), T]     	           )*i#	      R->$
16	[#, T, R, )]        	           )*i#	      T->$
17	[#, T, R]           	            *i#	          
18	[#, T, R, V, *]     	            *i#	    R->*VR
19	[#, T, R, V]        	             i#	          
20	[#, T, R, i]        	             i#	      V->i
21	[#, T, R]           	              #	          
22	[#, T]              	              #	      R->$
23	[#]                 	              #	      T->$
24	[]                  	               	          
句子符合文法规则
文法为：
Q->VR
R->*VR|$
S->QT
T->+QT|$
V->(S)|i
first集为：
Q=[(, i]
R=[$, *]
S=[(, i]
T=[$, +]
V=[(, i]
follow集为：
Q=[#, ), +]
R=[#, ), +]
S=[#, )]
T=[#, )]
V=[#, ), *, +]
预测分析表为：
 	|#        |(        |)        |i        |*        |+        |
-----------------------------------------------------------------
Q	|Q->null  |Q->VR    |Q->null  |Q->VR    |Q->null  |Q->null  |
R	|R->$     |R->null  |R->$     |R->null  |R->*VR   |R->$     |
S	|S->null  |S->QT    |S->null  |S->QT    |S->null  |S->null  |
T	|T->$     |T->null  |T->$     |T->null  |T->null  |T->+QT   |
V	|V->null  |V->(S)   |V->null  |V->i     |V->null  |V->null  |
FrankPointer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【编译原理】语法分析程序设计-用表驱动的预测分析法进行语法分析（C++）
qq_55930097的博客
07-09 911
本次实验通过设计和调试一个LL(1)语法分析程序，充分理解语法分析器的工作原理，掌握了LL(1)分析表的构造方法。词法分析的规则比较简单，不需要强大的文法来描述，它是编译过程的第一个阶段。语法分析是编译过程的一个逻辑阶段，此阶段的任务是在词法分析的基础上将单词序列组合成各类语法短语。
实验二 预测分析算法设计与实现
11-21
实验二 预测分析算法设计与实现，大家可以看看，如果有需要
编译原理：预测分析算法的设计与实现（含代码）
俊夫小瞳的博客
05-28 2624
一、实验目的 通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。 二、实验内容 输入文法及待分析的输入串，输出其预测分析过程及结果。 1. 参考数据结构 (1)/定义产生式的语法集结构/ typedef struct{ char formula[200];//产生式 }grammarElement; grammarElement gramOldSet[200];//原始文法的产生式集 (2)/变量定义/ char terSymbol[200];//终结符号 c
C语言 编译原理实验二 预测分析算法的设计与实现
weixin_52715149的博客
11-19 2810
#include<stdio.h> #include<stdlib.h> #include<string.h> #include<malloc.h> char grammer[200][200]; char stack[200]={'\0'}; int sp=0; int p1=0; int vtnum,vnnum,pronum; char vtsign[200]; char vnsign[200]; char firstSet[200][200];
LL(1)分析法（二） ——预测分析表构建与语法分析实现（编译原理）
热门推荐
m0_54759841的博客
04-10 1万+
LL(1)分析法 前期回顾与任务规划 下面对已完成的任务和未完成的任务进行梳理 已完成的任务 消除左递归 提取公共左因子 求解FIRST集 求解FOLLOW集 待完成的任务 判断文法是否为LL（1）文法 构建LL（1）预测分析表 对输入表达式进行LL(1)分析 异常处理机制 对于已完成的任务有不清楚的请参考第一篇文章 LL(1)分析法（一） ——文法预处理以及FIRST集FOLLOW集求解（编译原理） 下面废话少说让我们继续完成接下来的任务吧！！！加油！！ LL（1）文法判断 LL(1)文法的三个条
编译原理之预测分析法的实现(使用C/C++语言实现+使用栈的知识点))
努力敲代码的小盆友
05-30 1051
本文使用栈的知识进行编译原理中的预测分析法的代码编写。
实验二 预测分析算法的设计与实现.doc
03-11
实验二 预测分析算法的设计与实现 本实验报告的主要目的是设计和实现预测分析算法，以深入理解自上而下语法分析方法，特别是自上而下分析条件的理解。通过本实验，学生可以学习到预测分析算法的设计和实现过程，并...
编译原理实验之预测分析算法的设计与实现
09-09
这是鄙人完成老师的一个实验作业，写的还不错已比较详细，且代码中有大量注释帮助理解。使用时打开vc，在文件里选择打开工作区间，打开文件里的test2.dsw即可使用。里面的大量过程结果被鄙人注释掉了，打开1.cpp里的...
算符优先分析算法的设计与实现
11-30
实验三 算符优先分析算法的设计与实现，郑州大学，昝红英，编译原理，源码，已通过
语法分析：算术表达式预测分析程序设计(实验)
12-12
实验内容： 编程实现给定算术表达式的分析器。 算术表达式文法如下： E-->E+T|T T-->T*F|F F-->(E)|i （为DOC文档）
预测分析程序的设计与实现报告
11-30
根据算术表达式的语法定义，设计相应的产生式规则，并改造为LL(1)文法。根据此文法构造预测分析表和预测分析程序。该程序能够对输入字符串进行自上而下无回溯的语法分析，并输出“语法正确”或“语法错误”的结果。
【编译原理】实验二 预测分析算法的设计与实现
最新发布
qq_65319940的博客
01-23 1022
通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。输入文法及待分析的输入串，输出其预测分析过程及结果。1. 参考数据结构(1)/*定义产生式的语法集结构*///产生式//原始文法的产生式集(2)/*变量定义*///终结符号//非终结符号//所有符号//各产生式右部的FIRST集//各产生式左部的FOLLOW集//分析表2. 判断文法的左递归性，将左递归文法转换成非左递归文法。（该步骤可以省略，直接输入非左递归文法）。
表达式语法分析——预测分析法
shadowam的博客
11-13 2338
Problem Description  预测分析法是自顶向下分析的一种方法，一个预测分析程序是由三个部分组成： (1) 预测分析程序 (2) 先进后出栈 (3) 预测分析表 现给出表达式文法： E→TG G→+TG | ε T→FS S→*FS | ε      F→(E) | i 该表达式文法是LL(1)文法，其预测分析表为： 请根据该预测分析表构造预测分析程序，完成对...
编译原理实验二：预测分析算法的设计与实现（python）
CK_0ff的博客
12-15 1421
利用python，通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。
编译原理实验（二）—— 预测分析算法的设计与实现（C语言实现）
wowhhhgd的Blog
01-12 7693
大家好，下面介绍的是我当时上编译原理所做的实验，主要内容就是根据已有的文法，构造文法的first集和follow集，然后再根据构造好的first集和follow集构造预测分析表，最后，设置一个栈，然后利用栈和预测分析表来对输入串进行分析，判断输入串是否是该文法的一个合适的语法范畴。用的是最基本的C语言写的，如有不足，欢迎大家批评指正！ 一、实验目的 通过预测分析算法的设计与实现，加深对自上而下语法分析方法的理解，尤其是对自上而下分析条件的理解。 二、实验内容 输入文法及待分析的输入串，输出其预测分析过程及结
【编译原理】基于算符优先分析法的语法分析器
qq_51795098的博客
06-28 1579
【编译原理】基于算符优先分析法的语法分析器
【Compile】表驱动LL(1)语法分析(C++)
codeslogan
05-12 1118
题目描述 掌握预测分析程序的分析、设计与实现的基本技术与一般方法。 编写识别由下列文法所定义的表达式的预测分析程序。 E−>E+T∣E−T∣TE -> E+T | E-T | TE−>E+T∣E−T∣T T−>T∗F∣T/F∣FT ->T*F | T/F | FT−>T∗F∣T/F∣F F−>(E)∣iF ->(E) | iF−>(E)∣i 输入：从键盘输入表达式，或每行含有一个表达式的文本文件。其中，表达式中含有任意的十进制数或十六进制数，并以#结束。
语法分析：算术表达式预测分析程序设计
靠谱-ing
11-24 3175
1、实验目的： （1）掌握自上而下语法分析的要求与特点。 （2）掌握LL(1)语法分析的基本原理和方法。 （3）掌握相应数据结构的设计方法。 2、实验内容： 编程实现给定算术表达式的分析器。 算术表达式文法如下： E-->E+T|T T-->T*F|F F-->(E)|i 3、设计说明： 首先改写文法为LL(1)文法；构造LL(1)分析表，然后编写预测分析程序。 4、设计分析与步骤 （1）将原算术
预测分析法设计与实现用c语言
05-05
预测分析法（Predictive Analysis）是一种通过历史数据来预测未来趋势的方法。在C语言中，可以通过多种算法来实现预测分析，比如线性回归、逻辑回归、朴素贝叶斯等。以下是一个简单的线性回归实现的例子： ```c #include <stdio.h> // 线性回归函数 double linear_reg(int n, double x[], double y[]) { double sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0; for (int i = 0; i < n; i++) { sumX += x[i]; sumY += y[i]; sumXY += x[i] * y[i]; sumX2 += x[i] * x[i]; } double b = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX); double a = (sumY - b * sumX) / n; return a + b * x[n-1]; } int main() { double x[5] = {1, 2, 3, 4, 5}; // 输入数据 double y[5] = {2, 4, 6, 8, 10}; // 输出数据 printf("预测结果为：%lf\n", linear_reg(5, x, y)); // 预测结果 return 0; } ``` 以上是一个简单的预测分析方法的实现，具体的算法和实现方式可以根据实际需求进行选择和修改。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值