精华内容
下载资源
问答
  • 求助!关于栈的运用,算术四则运算表达式求值算符优先算法的源代码
    2021-05-26 00:53:53

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    #define MAXSIZE 64

    typedef int datatype;

    #include

    typedef struct

    {

    datatype data[MAXSIZE];

    int top;

    }seqstack;

    seqstack s;

    char in[20],out[20];

    ///

    void setnull()

    {

    s.top=-1;

    }

    bool empty()

    {

    if(s.top>=0)

    return false;

    else

    return true;

    }

    ///

    void push(int x)

    {

    if(s.top==MAXSIZE-1)

    printf("上溢!");

    else

    {

    s.top++;

    s.data[s.top]=x;

    }

    }

    ///

    datatype pop()

    {

    if(empty())

    {

    printf("下溢!");return NULL;

    }

    else

    {

    s.top--;

    return(s.data[s.top+1]);

    }

    }

    ///

    datatype top()

    {

    if(empty())

    {

    return NULL;

    }

    else

    return(s.data[s.top]);

    }

    ///

    bool yx(char c1,char c2)

    {

    if((c1=='*' && c2!='/')||(c1=='/' && c2!='*')||(c1=='+' && c2=='(')||(c1=='-' && c2=='('))

    return true;

    else

    return false;

    }

    ///

    void input()

    {

    scanf("%s",&in);

    }

    void zzh()

    {

    setnull();

    int i=0,j=0,k=0;

    while(in[i]!=0)

    {

    if(in[i]>47)

    {

    out[j]=in[i];

    j++;

    }

    else

    {

    if(empty())

    push(in[i]);

    else

    {

    if(in[i]=='(')

    {

    push(in[i]);

    }

    else if(in[i]==')')

    {

    while(top()!='(')

    {

    out[j]=pop();

    j++;

    }

    pop();

    }

    else

    {

    while(!yx(in[i],top()) && !empty())

    {

    out[j]=pop();

    j++;

    }

    push(in[i]);

    }

    }

    }

    i++;

    }

    while (!empty())

    {

    out[j]=pop();

    j++;

    }

    }

    ///

    int count()

    {

    int i=0,a,b;

    setnull();

    while(out[i]!=0)

    {

    if(out[i]>47)

    {

    push(out[i]-48);

    }

    else

    {

    if(out[i]=='+')

    {

    b=pop();

    a=pop();

    a=a+b;

    push(a);

    }

    if(out[i]=='-')

    {

    b=pop();

    a=pop();

    a=a-b;

    push(a);

    }

    if(out[i]=='*')

    {

    b=pop();

    a=pop();

    a=a*b;

    push(a);

    }

    if(out[i]=='/')

    {

    b=pop();

    a=pop();

    a=a/b;

    push(a);

    }

    }

    i++;

    }

    return pop();

    }

    void main()

    {

    printf("请输入中缀表达式:\n");

    input();

    zzh();

    printf("\n后缀表达式为:\n%s",out);

    printf("\n\n结果:%s=%d\n\n",in,count());

    }

    更多相关内容
  • 算符优先算法

    2014-06-27 16:13:54
    [实验项目] 实现算符优先分析算法,完成以下描述算术表达式的算符优先文法的算符优先分析过程。 G[E]:E→E+T∣E-T∣T T→T*F∣T/F∣F F→(E)∣i 说明:终结符号i为用户定义的简单变量,即标识符的定义。
  • 实现算符优先过程 具体的算法 和结构体 一般报告都适用
  • 任意表达式求值(算符优先算法

    千次阅读 2020-10-24 11:00:10
    这里写自定义目录标题任意表达式求值算符优先算符双栈算符定义处理逻辑如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个...

    任意表达式求值

    任意表达式求值的算法是很常用的一个功能,虽然python有自带的eval,但必须基于python语法。而我们很多时候想创建自己的DSL,表达式求值都是核心的功能。

    算符优先算符

    实现这个功能,其实就是编译器的功能,有很多种实现方法,本文使用的是经典的算符优先算法。这个算符非常简洁优雅,可扩展性很强,不但可以计算表达式,如果适度扩展,完全可以实现图灵完备的DSL。

    双栈

    算符优先算法的第一个核心是双栈,一个算符栈,一个计算数栈。如果一个算符只能对常数计算就太弱了,所以本文算法支持了外挂的变量系统。
    只需对isVar和getValue赋值,即可实现变量功能。

    如果不定义isVar,则所有变量直接当作字符串处理

    算符定义

    算符优先算法的第二个核心是算符定义,虽然是经典算法,但或许有同学忘了也说不定。所以这里简单介绍一下。
    任何一个算符(除了永不入栈的右括号)都有两个优先级,一个是栈外优先级,一个是栈内优先级。
    这个算符的运算包括几个运算数。
    以及实际执行计算的函数。

    opDict={}
    def addoptr(ch, outLev, inLev, func, parmNum=2):
        obj= {'name':ch, 'out':outLev, 'in':inLev, 'func':func, 'parmNum':parmNum}
        opDict[ch]= obj
    addoptr('#', 1, 1, None)
    addoptr('(', 90, 2, None)
    addoptr(')', 2, None, None)
    addoptr('&', 13, 14, lambda x: x[-1] and x[-2])
    addoptr('|', 11, 12, lambda x: x[-1] or x[-2])
    addoptr('~', 16, 17, lambda x: not x[-1],1)
    addoptr('=', 22, 23, lambda x: x[-1]==x[-2])
    addoptr('>', 22, 23, lambda x: x[-2]>x[-1])
    addoptr('<', 22, 23, lambda x: x[-2]<x[-1])
    addoptr('+', 31, 32, lambda x: x[-1]+x[-2])
    addoptr('-', 31, 32, lambda x: x[-2]-x[-1])
    addoptr('*', 41, 42, lambda x: x[-1]*x[-2])
    addoptr('/', 41, 42, lambda x: x[-2]/x[-1])
    
    

    注意大部分算符的栈内优先级都高于栈外优先级,是为了在连续遇到时可以优先计算前面的部分,比如3+5+2,第二个加号出现的时候,由于栈外优先级低于站内优先级,所以前面的3+5就被计算求值。

    处理逻辑

    处理逻辑相当简洁,见代码

        def eval(this, cond):
            stack=[]
            this.pushoptr('#')
            while True:
                aword,kind= this.readWord(cond)
                cond= cond[len(aword):].strip()
                if kind=='#':
                    this.pushoptr('#')
                    break
                elif kind=='optr':
                    this.pushoptr(aword)
                else:
                    this.pushopnd(aword)
                print(aword, cond)
                print(this.optrStack)
                print(this.opndStack)
            return this.popopnd()
    

    逐个从字符串中读取操作数和操作符,这里除了已经定义的操作符和空格之外,全都被定义为操作数。

    未实现的功能

    目前实现了逻辑、关系、计算表达式,可以直接适用于很多情况。
    由于项目所需功能有限,所以并没有实现完整。未实现的功能有:

    1. 负号/减号 这种一个符号两个含义的操作符暂未支持
    2. >=, <=, != 这种双字符的符号暂未支持
    3. 浮点数暂未支持

    如有兴趣,添加这些功能并不难。

    使用方法

    简单用法(无变量)

        a= exprEngine()
        b= a.eval('3 + 5 = 8 & ~(7 < 2)')
        print(b)
    

    有变量的用法

        a= thing()
        a.addInfo('水位', '高')
        b= a.eval('水位=高&3+5=8&~(7<2)')  
        #其中 a.eval的函数这样写
        en= exprEngine(this.isattr, this.getValue)
        return en.eval(cond)
    

    完整代码

    # 任意表达式的计算引擎
    # 目前不支持负数、浮点数
    # 不支持>=和<=等双字节符号
    # 使用算符优先算法,双栈
    opDict={}
    def addoptr(ch, outLev, inLev, func, parmNum=2):
        obj= {'name':ch, 'out':outLev, 'in':inLev, 'func':func, 'parmNum':parmNum}
        opDict[ch]= obj
    addoptr('#', 1, 1, None)
    addoptr('(', 90, 2, None)
    addoptr(')', 2, None, None)
    addoptr('&', 13, 14, lambda x: x[-1] and x[-2])
    addoptr('|', 11, 12, lambda x: x[-1] or x[-2])
    addoptr('~', 16, 17, lambda x: not x[-1],1)
    addoptr('=', 22, 23, lambda x: x[-1]==x[-2])
    addoptr('>', 22, 23, lambda x: x[-2]>x[-1])
    addoptr('<', 22, 23, lambda x: x[-2]<x[-1])
    addoptr('+', 31, 32, lambda x: x[-1]+x[-2])
    addoptr('-', 31, 32, lambda x: x[-2]-x[-1])
    addoptr('*', 41, 42, lambda x: x[-1]*x[-2])
    addoptr('/', 41, 42, lambda x: x[-2]/x[-1])
    
    class exprEngine:
        def __init__(this, isVar=None, getValue=None):
            this.opndStack=[]
            this.optrStack=[]
            this.isVar= isVar
            this.getValue= getValue
    
        def readWord(this, cond):
            cond= cond.strip()
            if cond=='':
                return '', '#'
            if cond[0] in '()&|~+-*/=><':
                return cond[0], 'optr'
            part= ''
            for ch in cond:
                if ch in '()&|~+-*/=>< ':
                    break
                part+=ch
            return part, 'opnd'
        def pushoptr(this, optr):
            op= opDict[optr].copy()
            if len(this.optrStack)==0:
                this.optrStack.append(op)
                return
            opTop= this.optrStack[-1]
            if op['out']> opTop['in']:
                this.optrStack.append(op)
            elif op['out']< opTop['in']:
                this.popoptr()
                # 这里递归
                this.pushoptr(optr)
            elif op['out']== opTop['in']:
                # 消括号对,简单弹出
                this.optrStack.pop()
        def popoptr(this):
            opTop= this.optrStack[-1]
            a= opTop['parmNum']
            if len(this.opndStack)<a:
                raise Exception('操作数不足,可能有语法错误!')
            ret= opTop['func'](this.opndStack[-a:])
            this.opndStack= this.opndStack[:-a]
            this.opndStack.append(ret)
            this.optrStack.pop()
        def pushopnd(this, opnd):
            if this.isVar and this.isVar(opnd):
                this.opndStack.append(this.getValue(opnd))
            else:
                if opnd.isdigit():
                    this.opndStack.append(int(opnd))
                else:
                    this.opndStack.append(opnd)
        def popopnd(this):
            if len(this.opndStack)==1:
                return this.opndStack[0]
            else:
                print(this.opndStack)
                print(this.optrStack)
                raise Exception('可能存在语法错误。')
        def eval(this, cond):
            stack=[]
            this.pushoptr('#')
            while True:
                aword,kind= this.readWord(cond)
                cond= cond[len(aword):].strip()
                if kind=='#':
                    this.pushoptr('#')
                    break
                elif kind=='optr':
                    this.pushoptr(aword)
                else:
                    this.pushopnd(aword)
                print(aword, cond)
                print(this.optrStack)
                print(this.opndStack)
            return this.popopnd()
    
    if __name__=='__main__':
        # print(opDict)
        a= exprEngine()
        # a.addInfo('水位', '低')
        b= a.eval('3 + 5 = 8 & ~(7 < 2)')
        print(b)
    

    为了调试,中间加了一些print输出,正式使用时,自行取消。

    展开全文
  • 编译课程设计带出错处理程序的算符优先算法.doc
  • 算符优先过程的模拟 输入一个文法可以的出相应的移进规约表
  • 编译原理实验4算符优先算法[参考].pdf
  • 数学与计算机学院编译原理实验报告 年级专业 学号 姓名 成绩 实验题目 算符优先...使用算符优先分析算法分析下面的文法 E #E# E E+T | T T T*F | F F P^F | P P (E) | i 其中 i 可以看作是一个终结符无需作词法分析具体
  • 【编译原理】算符优先算法

    万次阅读 多人点赞 2018-05-10 20:48:55
    1.项目要求实现算符优先分析算法。完成以下描述算术表达式的算符优先文法的算符优先分析过程。G[E]:E→E+T∣T T→T*F∣FF→(E)∣i构造该算符优先文法的优先关系矩阵或优先函数;输入串应是词法分析的输出二元式序列...

    1.项目要求

    实现算符优先分析算法。

    完成以下描述算术表达式的算符优先文法的算符优先分析过程。

    G[E]:

    E→E+T∣T  

    T→T*F∣F

    F→(E)∣i

    构造该算符优先文法的优先关系矩阵或优先函数;

    输入串应是词法分析的输出二元式序列,即某算术表达式“实验项目一”的输出结果。输出为输入串是否为该文法定义的算术表达式的判断结果。

    算符优先分析过程应能发现输入串出错。

    设计测试用例,并给出测试结果。

    2.实验思路:

    算符优先分析法是一种自底向上分析方法,也称移进-归约分析法,它的实现思想是对输入符号串自左向右进行扫描,并将输入符逐个移入一个后进先出栈中,边移入边分析,一旦栈顶符号串形成某个句型的句柄时,该句柄对应某产生式的右部,就用该产生式的左部非终结符代替相应右部的文法符号串,这称为一步归约。重复这一过程直到归约到栈中只剩文法的开始符号时则为分析成功,也就确认输入串是文法的句子。

    算符优先分析的基本思想是只规定算符之间的优先关系,也就是只考虑终结符之间的优先关系,不考虑非终结符之间的优先关系。在归约过程中只要找到可归约串就归约,并不考虑归约到那个非终结符名,算符优先分析的可归约串不一定是规范句型的句柄,所以算符优先归约不是规范归约。算符优先分析的可归约串是当前符号栈中的符号和剩余的输入符号构成句型的最左素短语。 

    3.实验原理

    本次实验给定了算术表达式,根据算术表达式给出优先关系表,因此主要实现的只是算符优先分析算法,firstvt和lastvt均没有进行构造。优先关系表如图

                

        +      

        *      

        i       

        (       

        )      

         #      

       +

        >

        <

        <

        <

       >

        >

       *

        >

        >

        <

        <

       > 

        >

       i  

        >

        >

     

     

       >

        > 

       (

        <

        <

        <

        <

       =

      

       )

        >

        >

     

     

       >

        >

       #

        <

        <

        <

        <

      

        =

     

    4. 实验代码

    #include<stdio.h>
    int find(int a,int b)   //构造优先关系表
    {
        int table[6][6] = {//数字1代表  > 数字-1代表  <  数字2代表空
                           1, -1, -1, -1, 1, 1,
                           1,  1, -1, -1, 1, 1,
                           1,  1,  2,  2, 1, 1,
                          -1,- 1, -1, -1, 0, 2,
                           1,  1,  2,  2, 1, 1,
                          -1, -1,- 1, -1, 2, 0
                          };
      return table[a-1][b-1];
    }
    int in_vt(char c)    //根据返回值到优先关系表里面查找优先关系
    {
        int n;
       switch(c)//判断是否是非终结符,不是非终结符返回0
       {
           case '+': n = 1; break;  case '*': n = 2; break;
           case 'i': n = 3; break;  case '(': n = 4; break;
           case ')': n = 5; break;  case '#': n = 6; break;
           default : n = 0;
       }
       return n;
    }
    int judge(char *p,int k,char *psc)
    {
            if(k == 1 && p[k] == '#' && (*psc == '+' || *psc == '*'))
            {
                printf("\n运算符前无操作数\n");
                return 0;
            }
            if((*psc == '+' || *psc == '*') && (*(psc + 1) == '+' || *(psc + 1) == '*'))
            {
                printf("\n运算符号不能相邻\n");
                return 0;
            }
            if(*psc == '#' && (*(psc - 1) == '+' || *(psc - 1) == '*'))
            {
                printf("\n运算符后无操作数\n");
                return 0;
            }
            return 1;
    }
    int main()
    {
       int  k;                   //栈顶指针
       char s[30] = {'\0'};      //分析栈
       char *ss;
       char in_c[50] = {'\0'};   //输入串
       char *psc;                //指向当前输入符号
       int  j;
       char q;
       int  flag;
       int  n;
    while(1)
    {
       printf("请输入要归约的字符串(以‘#’结束)\n");
       printf("例如:(i+i)*i\n");
       scanf("%s",in_c);
       n = 1;          //记录步骤
       k = 1;
       s[k] = '#';
       s[k+1] = '\0';    //初始化
       ss = s + 1;       //指向栈底
       psc = in_c;
       printf("\n步骤\t符号栈S\t\t优先关系\t当前符号\t输入串Str\t\n");
       while(1)
       {
              if(judge(s,k,psc) == 0)
              {
                      printf("\n出错!\n");
                      break;
              }
    
              if(in_vt(s[k]))
                  j = k;
              else
                  j = k - 1;
              flag = find(in_vt(s[j]),in_vt(*psc));
              if(flag == 1)  //s[j] > 当前输入字符
              {
                   do
                   {
                       q = s[j];
                       if(in_vt(s[j-1]))
                            j--;
                       else
                            j = j - 2;
                   }while(find(in_vt(s[j]),in_vt(q)) != -1);
                   printf("(%d)\t%-24s>\t\t%c\t\t%-32s\n",n++,ss,*psc,psc+1);
                   k = j + 1;
                   s[k] = 'N';
                   s[k+1] = '\0';
                   continue;
              }
              else if(flag == -1)//s[j]<当前输入字符
                   {
                       printf("(%d)\t%-24s<\t\t%c\t\t",n++,ss,*psc);
                       k++;
                       s[k] = *psc;
                       s[k+1] = '\0';
                       psc++;
                       printf("%-32s\n",psc);
                       continue;
                   }
                   else if(flag == 0)//s[j]=当前输入字符
                        {
                              if(s[j] == '#')
                              {
                                   printf("(%d)\t%-24s=\t\t#\t\n",n,ss);
                                   printf("\n归约成功!\n");
                                   break;
                              }
                              else
                              {
                                   printf("(%d)\t%-24s=\t\t%c\t\t",n++,ss,*psc);
                                   k++;
                                   s[k] = *psc;
                                   s[k+1] = '\0';
                                   psc++;
                                   printf("%-32s\n",psc);
                                   continue;
                              }
                         }
                         else
                         {
                              printf("(%d)\t%-24s无\t\t%c\t\t%-32s\\\n",n++,ss,*psc,psc+1);
                              printf("\n错误!\n");
                              break;
                         }
       }
    }
     return 0;
    }

    实验输入及程序运行输出结果:


    展开全文
  • 输入一个文法,会分析出结果,并输出算符优先表。
  • 为了实现这个算法,我们需要两个栈,一个是符号栈OPTR,另一个是数据栈OPND,算符预先设定好优先级,当解析到数字的时候,将其入数据栈 当解析到运算符的时候,比较它和之前一个运算符的优先级,如果比之前的优先级...

    这个例子是书上P52页栈应用举例的其中一个算法

    算法的简单描述

    为了实现这个算法,我们需要两个栈,一个是符号栈OPTR,另一个是数据栈OPND,算符预先设定好优先级,当解析到数字的时候,将其入数据栈

    当解析到运算符的时候,比较它和之前一个运算符的优先级,如果比之前的优先级高的话,先入栈,如果和之前的元素优先级一样的话,就可以将括号去掉了(因为这个时候已经算完了),如果比之前的优先级低的话,那么就需要将两个运算数据出栈,运算符也出栈,进行运算,然后将运算结果入栈,并且保留这个运算符继续进行比较。

    这里有一个小细节需要注意,就是,先出栈的是第二个运算数,后出栈的是第一个运算数,如果没有注意到的话做减法的时候符号是相反的。

    如果符号栈OPTR的栈底元素是#,并且当前元素也是#的话,表示解析结束

    算符优先级表如下所示

    代码实现

    我是用查表的方式来检查两个算符的优先级关系的

    用1表示theta1>theta2;用-1表示theta1<theta2;用2表示语法错误

    #include <iostream>
    #include <stdio.h>
    #include <stdlib.h>
    #include <stack>
    #include <ctype.h>
    using namespace std;
    
    stack<char> OPTR;   //初始化算符栈
    stack<int> OPND;    //初始化数据栈
    
    //算符优先级表,1表示大于,0表示等于,-1表示小于,2表示不合法
    //第一维是前一个算符,第二位是后一个算符
    int priority[7][7] = 
    {{1, 1, -1, -1, -1, 1, 1},
     {1, 1, -1, -1, -1, 1, 1},
     {1, 1, 1, 1, -1, 1, 1},
     {1, 1, 1, 1, -1, 1, 1},
     {-1, -1, -1, -1, -1, 0 , 2},
     {1, 1, 1, 1, 2, 1, 1},
     {-1, -1, -1, -1, -1, 2, 0}};
    
    //判断字符是不是运算符,如果是运算符返回1,不是运算符返回0
     int isOP(char c){
         if(c=='+' || c=='-' || c=='*' || c=='/' || 
            c=='(' || c==')' || c=='#'){
            return 1;       //是运算符
         } else {
            return 0;
         }
     }
    
    //查表程序,如果输入为3表示出错了
     int precede(char a1, char a2){
         int a=-1 , b=-1;
         switch(a1){
            case '+':
               a = 0;
               break;
            case '-':
               a = 1;
               break;
            case '*':
               a = 2;
               break;
            case '/':
               a = 3;
               break;
            case '(':
               a = 4;
               break;
            case ')':
               a = 5;
               break;
            case '#':
               a = 6;
               break;
            default:
            return 3;   //出错
               break; 
         }
         switch(a2){
            case '+':
               b = 0;
               break;
            case '-':
               b = 1;
               break;
            case '*':
               b = 2;
               break;
            case '/':
               b = 3;
               break;
            case '(':
               b = 4;
               break;
            case ')':
               b = 5;
               break;
            case '#':
               b = 6;
               break;
            default:
            return 3;   //出错
               break; 
         }
         return priority[a][b];
     }
    
     //进行运算,返回运算的结果
     int operate(int a, char theta, int b){
         switch(theta){
             case '+':
                printf("%d+%d = %d\n",a, b, a+b);
                return a+b;
             case '-':
                printf("%d-%d = %d\n",a, b, a-b);
                return a-b;
             case '*':
                printf("%d*%d = %d\n",a, b, a*b);
                return a*b;
             case '/':
                printf("%d/%d = %d\n",a, b, a/b);
                return a/b;
             default:
                printf("the op is %c\n", theta);
                return 0;
         }
     }
    
    //解析整数值,返回时c存的是下一个运算符号
    int getNumber(char &c){
       int num = 0;
       num += (c-'0');
       c = getchar();
       while(isdigit(c)){
          //printf("%c", c);
          num *= 10;
          num += (c-'0');
          c = getchar();
       }
       return num;
    }
    
    //解析表达式的主函数,返回解析得到的结果
    int expression(){
         OPTR.push('#');    //在开始的时候先将#入栈
         char c;
         c = getchar();
         while(c!='#' || OPTR.top() != '#'){  //只有当两个都是#时才结束解析
             //printf("%c", c);
             if(c == ' '){  //略过空格
                c = getchar();
                continue;
             }
             if(!isOP(c)){  //不是运算符则入数据栈
                int out = getNumber(c);
                //printf("out = %d\n", out);
                OPND.push(out);
             } else {    //是运算符
                int a = precede(OPTR.top(), c);
                //printf("a=%d\n", a);
                if(a == -1){   //当前运算符优先级小于前一个运算符
                   OPTR.push(c);
                   c = getchar();
                } else if(a == 0){   //运算符等级相等,直接消掉括号即可
                   OPTR.pop();
                   c = getchar();
                } else if(a == 1){   //进行运算
                   char b = OPTR.top();
                   OPTR.pop();
                   int a1 = OPND.top();
                   OPND.pop();
                   int a2 = OPND.top();
                   OPND.pop();
                   int out = operate(a2, b, a1);
                   //printf("out = %d\n", out);
                   OPND.push(out);
                   //注意,需要将这个算符继续比较
                } else if(a == 2){
                   printf("error\n");
                }
             }
         }
          return OPND.top();   //将最终的运算结果返回
    }
    
    int main(){
       freopen("in.txt", "r", stdin);
       printf("outcome = %d\n", expression());
    }

    测试用例(只有一个)

    20 * (10 - 2)#

    运算结果

    展开全文
  • #include<iostream.h> #include<string.h> #include<stdio.h> typedef struct { ?char R; ?char r; ?int flag; }array; typedef struct { ?char E; ?char e; }charLode; typedef struct { ?...int top
  • 算符优先分析器 #include "stdio.h" #include "stdlib.h" #include "iostream.h" char data[20][20]; //算符优先关系 char s[100]; //模拟符号栈s char lable[20]; //文法终极符集 char input[100]; //文法输入符号...
  • 本文件是用VC++6.0编写的算符优先算法,用于编译原理的课程设计,有需要的可以来下载!!!!!
  • 算符优先算法(Java)

    2009-05-19 10:19:35
    算符优先算法(Java) 比较好的语法分析程序!!
  • //算数表达式求值的算符优先算法 { optr=push(optr, '#' ); //’#’置于栈底,级别最低 char c=getchar(); //读入表达式,以’#’结束 while (c!= '#' ||GetTop(optr)!= '#' ) { if (isInt(c)) //若读入...
  • 算符优先算法实现

    千次阅读 2018-06-23 13:59:26
    实现算符优先算法,完成一个算符优先文法的算法优先分析过程。(1)根据给定文法,先求出FirstVt和LastVt集合,构造算符优先关系表(要求算符优先关系表输出到屏幕或者输出到文件);(2)根据算法和优先关系表分析给定...
  • 算符优先算法中优先函数的构造

    千次阅读 多人点赞 2020-11-04 10:29:09
    算符优先分析中“优先函数的简单构造!”
  • 编译原理课程实验报告,附加源代码,给力哦!
  • 我学编译原理时做的一个算符优先算法,希望对大家有所帮助
  • 实验三 算符优先分析算法的设计与实现 8 学时) 一 实验目的 根据算符优先分析法 对表达式进行语法分析 使其能够判断一个表达式是否正确 过算符优先分析方法的实现加深对自下而上语法分析方法的理解 二 实验要求 1...
  • 编译原理 中的算符优先算法,可以生成新的文法,产生终结符集,非终结符集,firstvt集,lastvt集,和标志符优先表。
  • 学编译时写的,写的感觉不简洁,但自我感觉很强大了,大概改一下基本可以交关于算符优先的任何作业了,呵呵 (自动算FIRST集,FOLLOW集和算符优先表)语法自己改改就行了~~ 作业交完了,拿出来看看谁需要
  • //优先关系表 char * input ; /*将光标移动到X,Y坐标处*/ void toxy ( int x , int y ) { COORD pos = { x , y } ; HANDLE Out = GetStdHandle ( STD_OUTPUT_HANDLE ) ; ...
  • 算符优先分析算法及其代码实现

    千次阅读 2020-11-06 23:01:52
    最近编译课要求写一个OPG的算法实现,记录一下~也希望帮助到你

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,046
精华内容 1,218
关键字:

算符优先算法