栈的运用（算数表达式求值的算符优先算法 十以内简单版）

最新推荐文章于 2022-06-09 09:09:16 发布
最新推荐文章于 2022-06-09 09:09:16 发布
阅读量5.8k 收藏 31
点赞数 6
分类专栏： 数据结构 栈 文章标签： 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wilver/article/details/51001156
版权

假定运算符有加(+)，减(-)，乘(*)，除(/))，操作数限制为一位数，圆括号看作分界符。

中缀表达式
a*b+c
a+b*c
a+(b*c+d)/e

后缀表达式（RPN)
ab*c+
abc*+
abc*d+e/+

中缀表达式：设两个栈，
操作数栈(opnd)和运算符栈(optr)

按以下规则进行：
若c级别高于optr栈顶的运算符，则c入optr栈；
若级别低于或等于optr栈顶的运算符，则弹出optr栈顶的运算符，并从opnd栈弹出两个数，进行相应运算，结果压入opnd栈；
若c=’(‘，则入optr栈；
若c=’)’，并且optr栈顶是’(‘，optr退栈，从而消去了两个括号；否则’)’被解释为级别低于其它运算符，要按上面规则进行，直到碰到’(‘，optr退栈；
若c=’#’， optr退栈，用弹出的运算符和从opnd栈弹出两个数作相应运算，结果压入opnd栈。这个过程一直进行到optr栈只剩’#’为止，运算结束。

例：3*（5-2）
步骤 . optr栈S1 . opnd栈 S2 . 输入字符 . 主要操作
－－－－－－－－－－－－－－－－－－－－－－－－－－
1 ………… # …. …………………….3*(5-2)# . push(s2,’3’)
2 ………….# …. ………. 3 …………..(5-2)# . push(s1,’’)
3 ………… #* …………..3……………(5-2)# . push(s1,’(’)
4 ………… #*( ………….3…………….5-2)# . push(s2,’5’)
5 ………… #*( ………….3 .5…………..-2)# . push(s1,’-’)
6…………. #*(- ……….. 3 .5…………..2)# . push(s2,’2’)
7…………. #*(- ……….. 3 .5.2…………)# . sum(‘5’,’-’,’2’ )
8…………. #*( ………… 3 .3……………)# . pop(s1){消除一对括号}
9…………. #* …………. 3 .3……………..# . sum(‘3’,’*’,’3’)
10………… # ………….. 9…………………# . return(gettop(s2))

最后注意一点，输入的数字不要大于9，且算数最大的时候不要超过79；

最后加：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;
typedef struct node
{
    char data;
    struct node *next;
} Node,*LinkList;
LinkList Createzhan1()//创建符号栈
{
    LinkList top;
    top=NULL;
    return top;
}
LinkList Createzhan2()//创建数据栈
{
    LinkList top2;
    top2=NULL;
    return top2;
}
LinkList push(LinkList s,char x)//栈中插入元素
{
    LinkList q,top=s;
    q=(LinkList)malloc(sizeof(Node));
    if(!q) return 0;
    q->data=x;
    q->next=top;
    top=q;
    return top;
}
LinkList pop(LinkList s,char &e)//删除栈顶元素
{
    e=s->data;
    LinkList p=s;
    s=s->next;
    free(p);
    return s;
}
char GetTop(LinkList s)//取得栈顶元素
{
    return s->data;
}
int precede(char op1, char op2)//考虑优先级函数
{
    if(op1 == ')'&& op2 == '(')
        return 2;
    else if (op1 == '('||op2 == '(' || op2 == '#')
        return 0;
    else if(op1 == ')')
        return 1;
    else if (op1 == '+' || op1 == '-')
    {
        return 1;
    }
    else if (op1 == '*' || op1 == '/')
    {
        if (op2 == '+' || op2 == '-')
            return 0;
        else
            return 1;
    }
}
int isInt(char a)//判断是不是整数
{
    if(a>='0'&&a<='9')
        return 1;
    else  return 0;
}
char sum(char a,char t,char b)
{
    int c=a-'0';
    int d=b-'0';
    if(t=='+')
    {
        a=c+d+'0';
        return a;
    }
    else if(t=='-')
    {
        a=c-d+'0';
        return a;
    }
    else if(t=='*')
    {
        a=c*d+'0';
        return a;
    }
    else if(t=='/')
    {
        a=c/d+'0';
        return a;
    }
}
char EvaluateExpression(LinkList optr,LinkList opnd)//算数表达式求值的算符优先算法
{
    optr=push(optr,'#');//’#’置于栈底，级别最低
    char c=getchar();//读入表达式，以’#’结束
    while(c!='#'||GetTop(optr)!='#')
    {
        if(isInt(c))//若读入字符c是数字字符，入栈
        {
            opnd=push(opnd,c);
            c=getchar();
        }
        else
        {
            if(precede(c,GetTop(optr))==2)//去括号
            {
                char x;
                optr=pop(optr,x);
                c=getchar();
            }
            else if(!precede(c,GetTop(optr)))//c级别高，入栈
            {
                optr=push(optr,c);
                c=getchar();
            }
            else if(precede(c,GetTop(optr)))
            {
                char a,b,t;
                opnd=pop(opnd,b);//弹出操作数
                opnd=pop(opnd,a);
                optr=pop(optr,t);//c级别低，弹出一个运算符
                opnd=push(opnd,sum(a,t,b));//进行相应运算，结果入栈
            }
        }
    }
    return GetTop(opnd);
}
int main()
{
    LinkList top1,top2;
    top1=Createzhan1();
    top2=Createzhan2();
    cout<<EvaluateExpression(top1,top2)-'0'<<endl;;
    return 0;
}

另一种：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;
typedef struct node
{
    char data;
    struct node *next;
} Node,*LinkList;
LinkList Createzhan1()//创建符号栈
{
    LinkList top;
    top=NULL;
    return top;
}
LinkList Createzhan2()//创建数据栈
{
    LinkList top2;
    top2=NULL;
    return top2;
}
LinkList push(LinkList s,char x)//栈中插入元素
{
    LinkList q,top=s;
    q=(LinkList)malloc(sizeof(Node));
    if(!q) return 0;
    q->data=x;
    q->next=top;
    top=q;
    return top;
}
LinkList pop(LinkList s,char &e)//删除栈顶元素
{
    e=s->data;
    LinkList p=s;
    s=s->next;
    free(p);
    return s;
}
char GetTop(LinkList s)//取得栈顶元素
{
    return s->data;
}
int precede(char a)//将符号优先级换成数字
{
    if(a=='+'||a=='-')
        return 2;
    else if(a=='*'||a=='/')
        return 3;
    else if(a=='('||a==')')
        return 1;
    else if(a=='#')
        return 0;
}
int isInt(char a)//判断是不是整数
{
    if(a>='0'&&a<='9')
        return 1;
    else  return 0;
}
char sum(char a,char t,char b)
{
    int c=a-'0';
    int d=b-'0';
    if(t=='+')
    {
        a=c+d+'0';
        return a;
    }
    else if(t=='-')
    {
        a=c-d+'0';
        return a;
    }
    else if(t=='*')
    {
        a=c*d+'0';
        return a;
    }
    else if(t=='/')
    {
        a=c/d+'0';
        return a;
    }
}
char EvaluateExpression(LinkList optr,LinkList opnd)//算数表达式求值的算符优先算法
{
    optr=push(optr,'#');//’#’置于栈底，级别最低
    char c=getchar();//读入表达式，以’#’结束
    while(c!='#'||GetTop(optr)!='#')
    {
        if(isInt(c))//若读入字符c是数字字符，入栈
        {
            opnd=push(opnd,c);
            c=getchar();
        }
        else
        {
            if(precede(c)>precede(GetTop(optr))||c=='(')//c级别高，入栈;或c为（
            {
                optr=push(optr,c);
                c=getchar();
            }
            else if((precede(c)==precede(GetTop(optr)))&&(c==')'))//去括号
            {
                char x;
                optr=pop(optr,x);
                c=getchar();
            }
            else if(precede(c)==precede(GetTop(optr)))
            {
                char a,b,t;
                opnd=pop(opnd,b);//弹出操作数
                opnd=pop(opnd,a);
                optr=pop(optr,t);//c级别低，弹出一个运算符
                opnd=push(opnd,sum(a,t,b));//进行相应运算，结果入栈
            }
            else if(precede(c)<precede(GetTop(optr)))
            {
                char a,b,t;
                opnd=pop(opnd,b);//弹出操作数
                opnd=pop(opnd,a);
                optr=pop(optr,t);//c级别低，弹出一个运算符
                opnd=push(opnd,sum(a,t,b));//进行相应运算，结果入栈
            }
        }
    }
    return GetTop(opnd);
}
int main()
{
    LinkList top1,top2;
    top1=Createzhan1();
    top2=Createzhan2();
    cout<<EvaluateExpression(top1,top2)-'0'<<endl;;
    return 0;
}

能重复输入的：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;
typedef struct node
{
    char data;
    struct node *next;
} Node,*LinkList;
LinkList Createzhan1()//创建符号栈
{
    LinkList top;
    top=NULL;
    return top;
}
LinkList Createzhan2()//创建数据栈
{
    LinkList top2;
    top2=NULL;
    return top2;
}
LinkList push(LinkList s,char x)//栈中插入元素
{
    LinkList q,top=s;
    q=(LinkList)malloc(sizeof(Node));
    if(!q) return 0;
    q->data=x;
    q->next=top;
    top=q;
    return top;
}
LinkList pop(LinkList s,char &e)//删除栈顶元素
{
    e=s->data;
    LinkList p=s;
    s=s->next;
    free(p);
    return s;
}
char GetTop(LinkList s)//取得栈顶元素
{
    return s->data;
}
int precede(char a)//将符号优先级换成数字
{
    if(a=='+'||a=='-')
        return 2;
    else if(a=='*'||a=='/')
        return 3;
    else if(a=='('||a==')')
        return 1;
    else if(a=='#')
        return 0;
}
int isInt(char a)//判断是不是整数
{
    if(a>='0'&&a<='9')
        return 1;
    else  return 0;
}
char sum(char a,char t,char b)
{
    int c=a-'0';
    int d=b-'0';
    if(t=='+')
    {
        a=c+d+'0';
        return a;
    }
    else if(t=='-')
    {
        a=c-d+'0';
        return a;
    }
    else if(t=='*')
    {
        a=c*d+'0';
        return a;
    }
    else if(t=='/')
    {
        a=c/d+'0';
        return a;
    }
}
int main()
{
    LinkList optr,opnd;
    optr=Createzhan1();
    opnd=Createzhan2();
    optr=push(optr,'#');//’#’置于栈底，级别最低
    char c;
    while(scanf(" %c",&c)!=-1)//读入表达式，以’#’结束
    {
        while(c!='#'||GetTop(optr)!='#')
        {
            if(isInt(c))//若读入字符c是数字字符，入栈
            {
                opnd=push(opnd,c);
                c=getchar();
            }
            else
            {
                if(precede(c)>precede(GetTop(optr))||c=='(')//c级别高，入栈;或c为（
                {
                    optr=push(optr,c);
                    c=getchar();
                }
                else if((precede(c)==precede(GetTop(optr)))&&(c==')'))//去括号
                {
                    char x;
                    optr=pop(optr,x);
                    c=getchar();
                }
                else if(precede(c)==precede(GetTop(optr)))//去括号
                {
                    char a,b,t;
                    opnd=pop(opnd,b);//弹出操作数
                    opnd=pop(opnd,a);
                    optr=pop(optr,t);//c级别低，弹出一个运算符
                    opnd=push(opnd,sum(a,t,b));//进行相应运算，结果入栈
                }
                else if(precede(c)<precede(GetTop(optr)))
                {
                    char a,b,t;
                    opnd=pop(opnd,b);//弹出操作数
                    opnd=pop(opnd,a);
                    optr=pop(optr,t);//c级别低，弹出一个运算符
                    opnd=push(opnd,sum(a,t,b));//进行相应运算，结果入栈
                }
            }
        }
        cout<<(int)(GetTop(opnd)-'0')<<endl;
        opnd=pop(opnd,c);
    }
    return 0;
}
徐诚武
关注
  • 6
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
数据结构-算术表达式-算符优先法
blanKey的博客
10-23 4692
代码还添加了乘方的优先级，自行参考 一开始我写的只能输入个位数，后来想了好久才解决，主要是在判断是否为运算符后，若不是运算符，别急着入栈，用一个标记数组记着，若下一个字符还不是运算符，则利用strcat函数链接之前标记数组和这一个字符，直到下一个字符是运算符为止，才入栈。至于负数的运算，则要判断是否连续两个都为运算符，且前一个运算符为‘（’后一个运算符为‘-’，若是就加个0入栈即可。#includ
设计一个程序，演示用算符优先法对算术表达式求值的过程
11-17
表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 基本要求：以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。利用教科书表3.1给出的算符优先关系，实现对算术四则混合运算表达式的求值，并仿照教科书的例3-1演示在求值中运算符栈、运算数栈、输入字符和主要操作的变化过程。 测试数据:3*(7-2);8;1+2+3+4;(((6+6)*6+3)*2+6)*2;(20+2)*(6/2);
用算符优先法对算术表达式求值
10-29
基于运算符栈和运算数栈，利用算符优先法对输入的中缀表达式求值。
c语言栈实现算符优先算法,求助！关于栈的运用，算术四则运算表达式求值算符优先算法的源代码...
weixin_42306054的博客
05-25 201
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#defineMAXSIZE64typedefintdatatype;#includetypedefstruct{datatypedata[MAXSIZE];inttop;}seqstack;seqstacks;charin[20],out[20];////////////////////////////////////////////...
算符优先算法进行表达式求值
12-22
使用操作符栈和操作数栈，算符优先算法进行表达式求值
数据结构课程设计-用栈实现表达式求值的方法详解
01-01
1、需求分析设计一个程序，演示用算符优先法对算术表达式求值的过程。利用算符优先关系，实现对算术四则混合运算表达式的求值。（1）输入的形式：表达式，例如2*(3+4) 包含的运算符只能有’+’ 、’-‘ 、’*’ 、...
数据结构课设——算数表达式求值[文].pdf
10-14
数据结构课设——算数表达式求值 数据结构课设——算数表达式求值是软件网络技术领域中的一项重要课设，旨在让学生掌握算数表达式的求值方法和数据结构的应用。 算术表达式是一种由操作数、运算符和界限符组成的...
17061833 _於文卓_算数表达式求值演示1
08-08
1. **算数表达式求值**：程序的目标是设计一个能够处理不含变量的整数算术表达式的求值系统，例如加、减、乘、除等四则运算。 2. **算符优先法**：这是一种解析和计算表达式的方法，依据操作符的优先级进行计算。在...
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
设计一个程序，演示用算符优先法对算术表达式求值的过程。 【基本要求】 以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。利用运算符优先关系，实现对算术四则混合运算表达式的求值。 【测试数据】 ...
用算符优先方法实现语法分析
12-09
本文将深入探讨一种常用的语法分析方法——算符优先方法，以及如何利用这种方法实现一个处理算术表达式的文法。 算符优先分析法是一种自底向上的语法分析技术，它基于算符的优先级和结合性来解析输入的符号序列。...
中缀表达式的求值（栈实现）
08-05
模拟计算器的功能，对输入的一串表达式进行求值。算法定义了运算符的优先级，最后利用栈的方法来实现。
表达式求值（采用栈实现）
10-15
利用栈实现算术表达式的求值，表达式中可包含加+、减（负） -、乘*、除/、 乘方^、括号( )运算符，操作数可以为浮点数。 可采用直接求中缀表达式的方法， 也可采用先转换成后缀表达式后再求值的方法（参看课件） 。 实现时需注意如下： （ 1）带小数点的数值生成 （ 理解整数数值的生成，小数部分的处理与之类似）。 （ 2）考虑负号的情况。负号与减号形式上一样，如何区分？ • 输入的表达式串中第 1 个字符是’-’ – 可断定此’-’是负号 • 其余的’-’ – 若紧接在’(’之后的’-’可断定是负号 （ 3）负号的处理 • 方法 1：若已断定是负号，可先压入数值 0 进入操作数栈，如此，可 将负号看作减号。 • 方法 2： 若已断定是负号，则紧接其后的数字字符转换成数值后，要 将其对应的相反数(负数)压入操作数栈
编译原理的算符优先算法实现
11-11
编译原理课程设计写的一个简单的算符优先算法。
算符优先算法
weixin_30764137的博客
04-16 1008
为了实现算符优先算法，可以实用两个工作栈。一个称作OPTR，用于寄存运算符；另一个称作OPTNCVD，用于寄存操作数或运算结果。算法的思想是： 1）首先置操作数栈为空栈，表达式起始符“#”为运算符的栈底元素； 2）依次读入表达式中每一个字符，若是操作数则进OPND栈，若是运算符，则和OPTR栈的栈顶运算符比较优先权后作相应操作，直至整个表达式求值完毕（即OPTR栈的栈顶元素和当前读入的字符...
栈的应用 之 用算符优先法求表达式的值
ESESZB的博客
10-25 2572
输入为表达式，以‘#’结尾 例如：2+3*(33-23) +5/4# #include #include #include #include #include   #include using namespace std; char ch[10]={'+','-','*','/','(',')','#'}; int compare[7][7]=
用算符优先法对算术表达式求值（六）
热门推荐
猪脚三父
11-23 1万+
18.11.23 这是一道最近刚上的实验课的题目。。。。 基于C语言，欢迎指正 实验要求 掌握栈在解决实际问题中的应用，设计一个程序，演算用算符优先法对算术表达式求值的过程，利用算符优先关系，实现对算术四则混合运算表达式的求值 。。挺难的。。 思路在这！ 思路 这个程序是这样，当你点击运行它的时候，你需要输一个表达式，然后按个回车，答案就出来了，跟个计算器一样 那么，在一开始，我们需要一个数组，来...
数据结构学习笔记三：算符优先算法
weixin_30782293的博客
08-11 416
给出一个表达式 2*(3-1),迅雷不及掩耳，立马知道答案为4，但是计算机可没有这样的能耐，它只知道直接计算，却不知道优先级。如此，我们需要自己用代码来告诉它算符的优先级 从左至右 先乘除后加减 先括号内后括号外 先来研究简单的算术表达式，只有+-*/（）运算符 算符优先表如上图，其中#为结束标识符。 现在来纠结具体的实现。 /// <summary&gt...
【数据结构】使用栈实现的算符优先算法
haohulala的博客
07-08 6847
这个例子是书上P52页栈应用举例的其中一个算法 算法的简单描述 为了实现这个算法，我们需要两个栈，一个是符号栈OPTR，另一个是数据栈OPND，算符预先设定好优先级，当解析到数字的时候，将其入数据栈 当解析到运算符的时候，比较它和之前一个运算符的优先级，如果比之前的优先级高的话，先入栈，如果和之前的元素优先级一样的话，就可以将括号去掉了（因为这个时候已经算完了），如果比之前的优先级低的话，那...
编译原理——根源已知算符优先矩阵求解bell矩阵，进而求出算符优先函数
han2023443149的博客
06-09 736
编译原理——bell有向图
算符优先算法为表达式求值
最新发布
06-07
算符优先算法是一种用于表达式求值的算法，它可以通过定义算符优先级来对表达式进行分析和计算。该算法的基本思路是，将表达式转化为一个由操作符和操作数组成的序列，然后按照操作符的优先级进行计算。 具体来说，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值