后缀表达式(栈)

后缀表达式

Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other)

Total Submission(s) : 0   Accepted Submission(s) : 0

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

输入一个中缀表达式(由0-9组成的运算数、加+减-乘*除/四种运算符、左右小括号组成。注意“-”也可以作为负数的标志,表达式以“@”作为结束符),判断表达式是否合法,如果不合法,请输出“NO”,否则请把表达式转换成后缀形式,再求出后缀表达式的值并输出。

Input

输入的第一行为T,表示测试示例的个数。对于每组测试数据为一个以@结束的字符串表达式。

Output

对于每组测试数据,输出2行,第一行为转换的后缀表达式,第二行为表达式的值。

Sample Input

1

1+2*[email protected]

Sample Output

128*+9-

8

会表达式求值就好办,这题主要区别在于表达式可能不合法,并且需要把栈里面的东西输出,那么用一个数组保存后缀表达式就行了。

#include<cstdio>
#include<stack>
#include<cstring>
using namespace std;

int yx(char c)
{
    if(c=='+'||c=='-') return 1;
    else if(c=='*'||c=='/') return 2;
    else if(c=='^') return 3;
    else if(c=='(') return 0;
}

int compute(stack<int> &s1,stack<char> &s2)
{
    int x,y,ans;
    char c;
    if(!s1.empty()) {y=s1.top();s1.pop();}
    else return -1;
    if(!s1.empty()) {x=s1.top();s1.pop();}
    else return -1;
    c=s2.top();s2.pop();
    if(c=='+') ans=x+y;
    else if(c=='-') ans=x-y;
    else if(c=='*') ans=x*y;
    else if(c=='/') ans=x/y;
    else if(c=='^')
    {
        int i,a=1;
        for(i=1;i<=y;i++)
            a*=x;
        ans=a;
    }
    s1.push(ans);
    return 0;
}

int main()
{
    int n,i,j,a[100];
    char s[100];
    scanf("%d\n",&n);
    while(n--)
    {
        int flag=0,num=0,a_count=0,result=0;
        stack<int>s_int;
        stack<char>s_char;
        gets(s);
        for(i=0;s[i]!='@';i++)
        {
            if(result== -1) break;
            if(s[i]>='0'&&s[i]<='9') {num=num*10+num+s[i]-'0';flag=1;}
            else
            {
                if(i==0&&s[i]=='-'||s[i-1]=='('&&s[i]=='-') {flag=2;break;}
                if(flag)
                {
                    if(flag==1)
                    {
                        s_int.push(num);
                        char c[100];int count=0;
                        while(num)
                        {
                            c[count++]=num%10+'0';
                            num/=10;
                        }
                        for(j=count-1;j>=0;j--) a[a_count++]= c[j];
                    }
                    if(flag==2)
                    {
                        s_int.push(-1*num);
                        char c[100];int count=0;
                        a[a_count++]='-';
                        while(num)
                        {
                            c[count++]=num%10+'0';
                            num/=10;
                        }
                        for(j=count-1;j>=0;j--) a[a_count++]=c[j];
                    }
                    num=0;flag=0;
                }
                if(s[i]=='(')  {s_char.push(s[i]);continue;}
                else if(s[i]==')')
                {
                    while(!s_char.empty()&&s_char.top()!='(')
                    {a[a_count++]=s_char.top();if(compute(s_int,s_char)==-1) {result=-1;break;}};
                    s_char.pop();
                    continue;
                }
                if(s_char.empty()) s_char.push(s[i]);
                else
                {
                    while(!s_char.empty()&&yx(s_char.top())>=yx(s[i]))
                    {
                        a[a_count++]=s_char.top();
                        if(compute(s_int,s_char)==-1) {result=-1;break;}
                    }
                    s_char.push(s[i]);
                }
            }
        }
        if(flag)
        {
            if(flag==1)
            {
               s_int.push(num);
               char c[100];int count=0;
               while(num)
               {
                   c[count++]=num%10+'0';
                   num/=10;
               }
               for(j=count-1;j>=0;j--) a[a_count++]=c[j];
            }
            if(flag==2)
            {
                s_int.push(-1*num);
                char c[100];int count=0;
                a[a_count++]='-';
                while(num)
                {
                    c[count++]=num%10+'0';
                    num/=10;
                }
                for(j=count-1;j>=0;j--) a[a_count++]=c[j];
            }
        }
        while(!s_char.empty()) {a[a_count++]=s_char.top();if(compute(s_int,s_char)==-1) result=-1;break;}
        if(result==0)
        {
            a[a_count]='\0';
            for(i=0;a[i]!='\0';i++) printf("%c",a[i]); printf("\n");
            printf("%d\n",s_int.top());
        }
        else puts("NO");
        while(!s_char.empty()) s_char.pop();
        while(!s_int.empty()) s_int.pop();
    }
    return 0;
}
时间: 2024-08-29 06:37:10

后缀表达式(栈)的相关文章

洛谷P1449 后缀表达式 栈 模拟 字符串

洛谷P1449 后缀表达式 栈 模拟 字符串 栈模拟一下 碰到 . 如果输入的是数字就把数字放进栈中 1 #include <cstdio> 2 #include <cstring> 3 #include <cmath> 4 #include <cstdlib> 5 #include <string> 6 #include <algorithm> 7 #include <iomanip> 8 #include <io

中缀表达式转后缀表达式---栈--二叉树---四则运算

我们平常书写的四则运算表达式属于中缀表达式,形式为"9+(3-1)*3+10/2",因为所有的运算符号都在两操作数之间,所以称为中缀表达式.我们使用中缀表达式来计算表达式的值,不过这种形式并不适合计算机求解.接下来,我们将中缀表达式转化为后缀表达式,所谓的后缀表达式就是操作符位于操作数后面的不包含括号的算数表达式,也叫做逆波兰表达式. 1)首先介绍一种人工的转化方法(http://www.cnblogs.com/MichaelYin/archive/2012/05/02/2479248

数据结构实践——后缀表达式(栈)

本文是针对数据结构基础系列网络课程(3):栈和队列的实现项目. [项目 - 后缀表达式] 利用sqstack.h中栈的基本运算,实现将一个中缀表达式转换为对应的后缀表达式的算法.例如,输入(56-20)/(4+2),输出后缀表达式::56#20#-4#2#+/要求在数字后加#. 参考解答说明: 原理见视频 栈的应用1-表达式求值,还可以参考表达式求值的源码 基于栈结构,将中缀表达式转换为后缀表达式的算法步骤是: 初始化运算符栈op; 将'='进栈; 从exp读取字符ch; while (ch!=

逆波兰表达式——中缀表达式转后缀表达式

逆波兰表达式 先说一下中缀表达式,平时我们使用的运算表达式就是中缀表达式,例如1+3*2,中缀表达式的特点就是:二元运算符总是置于与之相关的两个运算对象之间 人读起来比较好理解,但是计算机处理起来就很麻烦,运算顺序往往因表达式的内容而定,不具规律性 后缀表达式,后缀表达式的特点就是:每一运算符都置于其运算对象之后,以上面的中缀表达式1+2*3为例子,转为后缀表达式就是123*+ 下面先分析怎么把中缀表达式转换为后缀表达式,这里我们考虑六种操作符'+'.'-'.'*'.'/'.'('.')',完成

[题解]P1449 后缀表达式

[题解]P1449 后缀表达式(栈) 题目链接:P1449 后缀表达式 题目描述: 所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右新进行(不用考虑运算符的优先级). 如:3(5–2)+7对应的后缀表达式为:3.5.2.-7.[email protected].'@'为表达式的结束符号.'.'为操作数的结束符号. 输入格式:输入:后缀表达式 输出格式:输出:表达式的值 输入输出样例: 输入 #1 3.5.2.-*[e

四则运算使用栈和后缀表达式

我们在一般的四则运算都是中缀表达式. 别问我什么是中缀表达式. 我就知道符号两边是数字.也就是符号在中间. 1+3 什么是后缀表达式呢? 13+ 符号在后面. 那么就有人奇怪了,为什么我要使用后缀表达式呢? 问题就是运算的时候,在编程实现的时候,后缀表达式比中缀表达式好用呗. 没事,不理解那里好用没事,我们先把中缀表达式转换成后缀表达式然后实际看看就知道了. 从左到右依次读取 运算数,输出 左括号,入栈 右括号,将栈顶的运算符并输出,直到遇到左括号 运算符 { 若优先级大于栈顶运算符,入栈 若优

栈的应用 - 后缀表达式转中缀表达式

有关栈API详情请参看我的另一篇博文:栈的链式存储 - API实现 实例: 5 + 4=> 5 4 + 1 + 2 * 3 => 1 2 3 * + 8 + ( 3 – 1 ) * 5 => 8 3 1 – 5 * + 中缀表达式符合人类的阅读和思维习惯 后缀表达式符合计算机的"运算习惯" 中缀转后缀算法: 遍历中缀表达式中的数字和符号 对于数字:直接输出 对于符号: 左括号:进栈 运算符号:与栈顶符号进行优先级比较 若栈顶符号优先级低:此符合进栈 (默认栈顶若是左括

洛谷P1449——后缀表达式(栈模拟)

题目描述 所谓后缀表达式是指这样的一个表达式:式中不再引用括号,运算符号放在两个运算对象之后,所有计算按运算符号出现的顺序,严格地由左而右新进行(不用考虑运算符的优先级). 如:3*(5–2)+7对应的后缀表达式为:3.5.2.-*7.[email protected].'@'为表达式的结束符号.'.'为操作数的结束符号. 输入输出格式 输入格式: 输入:后缀表达式 输出格式: 输出:表达式的值 输入输出样例 输入样例#1: 3.5.2.-*[email protected] 输出样例#1: 1

栈 之 求后缀表达式

最近学习了栈,为了巩固知识,照着书实现了一个有关于栈的应用的例子:将中缀表达式转化为后缀表达式. 这里先来明白什么是中缀表达式:我们正常使用的算式,如a + b * c 就是一个中缀表达式.中缀表达式的特点就是运算符在中间. 后缀表达式就是 运算符在后面,像上面的式子如果转化为后缀表达式就为  a b * + . 这里以测试用例:A*B(B+C)-D/(E+F) 来为大家介绍一下转化的过程. 由中缀表达式中读取的字符 分解中缀表达式的过程 求后缀表达式的过程 栈中的内容 规则 A A 将操作数A

栈的应用之中缀表达式转后缀表达式

1,中缀表达式的定义及为什么要将中缀表达式转换为后缀表达式? 中缀表达式(中缀记法) 中缀表达式是一种通用的算术或逻辑公式表示方法,操作符以中缀形式处于操作数的中间.中缀表达式是人们常用的算术表示方法. 虽然人的大脑很容易理解与分析中缀表达式,但对计算机来说中缀表达式却是很复杂的,因此计算表达式的值时,通常需要先将中缀表达式转换为前缀或后缀表达式,然后再进行求值.对计算机来说,计算前缀或后缀表达式的值要比中缀表达式简单. 比如,计算机计算后缀表达式的过程如下----后缀表达式的计算机求值: 从左