C++实现 逆波兰表达式计算问题

          C++实现 逆波兰表达式计算问题

#include <iostream>
#include <string>
using namespace std;
class Stack
{
private:
    int size;
    int top;
    float *listArray;
public:
    Stack(int sz=20);
    ~Stack();
    bool push(float it);//入栈
    bool pop(float& it);//出栈
    bool isEmpty();//判断栈是否为空
    bool isOne();//判断栈里是否一个元素
};
Stack::Stack(int sz)  //栈构造函数
{
    size=sz;
    top=0;
    listArray=new float[size];
}
bool Stack::push(float it)
{
    if(top==size)
        return false;
    listArray[top++]=it;
    return true;
}
bool Stack::pop(float& it)
{
    if(top==0)
        return false;
    it=listArray[--top];
    return true;
}
bool Stack::isEmpty() //判断站是否为空
{
    if(top==0)
        return true;
    return false;
}
bool Stack::isOne()
{
    if(top==1)
        return true;
    return false;
}
Stack::~Stack()
{
    delete listArray;
}
//此函数传进输入的字符串,并对字符串进//行扫描并进行相应处理,得到结果(函数声//明)
void compute(char* str);
int main()
{
    char str[20];
    cin.getline(str,20,‘#‘);
    compute(str);
    return 0;
}
//此函数传进输入的字符串,并对字符串进//行扫描并进行相应处理,得到结果(函数体)
void compute(char*  str)
{
    Stack aStack;
    float x=0,y=0,s1,s2,temp;
    int i;
    i=0;
    while(str[i])
    {
        switch(str[i])
        {
            case ‘+‘: //加法运算
            if(aStack.isOne()||aStack.isEmpty())
            {
                cout << "表达式不符合要求";
                    return;
                }
                aStack.pop(s1);
                aStack.pop(s2);
                x=s2+s1;
                aStack.push(x);
                x=0;i++;break;
            case ‘-‘: //减法运算
            if(aStack.isOne()||aStack.isEmpty())
            {    cout << "表达式不符合要求";
                        return;
            }
            aStack.pop(s1); aStack.pop(s2);
            x=s2-s1;
            aStack.push(x);
            x=0;
             i++;
            break;
            case ‘*‘: //乘法运算
            if(aStack.isOne()||aStack.isEmpty())
            {
                cout << "表达式不符合要求";
                return;
            }
            aStack.pop(s1); aStack.pop(s2);
            x=s2*s1;
            aStack.push(x);
            x=0;
            i++;
            break;
            case ‘/‘: //除法运算
            if(aStack.isOne()||aStack.isEmpty())
            {
                cout << "表达式不符合要求";
                return;
            }
            aStack.pop(s1);
            aStack.pop(s2);
            if(s1==0)
            {
            cout << "分母为0!" << endl;
            return;
            }
            x=s2/s1;
            aStack.push(x);
            x=0;
            i++;
            break;
            case ‘ ‘: //如果是空格,将数据x押入栈中
            if(str[i-1]>=48&&str[i-1]<=57)
                    aStack.push(x);
                x=0;
                i++;
                y=0;
                break;
            case ‘.‘: //获得小数部分
            temp=10.0;
            while(str[++i]!=‘ ‘)                     {
                    if(str[i]>=48&&str[i]<=57)                y=y+(str[i]-48)/temp;
                    temp*=10;
                }
                x+=y;
                break;
            default: //将字符数字转换为浮点型的数字
            if(str[i]>=48&&str[i]<=57)                {
            x=x*10+str[i]-48;
                    i++;
                }
            }
        }
//判断栈是否只有切仅有一个元素,是就输//出结果
if(aStack.isOne())    {
        aStack.pop(x);
        cout << str << ‘=‘ << x << endl;
    }
}
时间: 2025-01-04 22:18:53

C++实现 逆波兰表达式计算问题的相关文章

逆波兰表达式计算(后缀表达式)

#include<iostream> #include<cstdlib> #include<cctype> using namespace std; template<class T> class stack { private: T* base; T* top; int stackSize; public: stack(int a=100):stackSize(a) { base=top=new T[stackSize]; } ~stack() { del

逆波兰表达式计算

逆波兰表达式又叫做后缀表达式.在通常的表达式中,二元运算符总是置于与之相关的两个运算对象之间,这种表示法也称为中缀表示. #include<iostream> #include<assert.h> using namespace std; class Stack { public:  Stack()   :_array(NULL)   , _size(0)   , _capacity(0)  {}  Stack(const Stack<T>& s)   :_ar

逆波兰表达式的实现

一般情况下表达式是由操作数和运算符组成,例如算数表达式中通常将运算符放在两个操作数中间,譬如a+b的形式,这种形式称为中缀表达式,那么问题来了,是否有后缀表达,前缀表达式呢??? 对,没错,这些后缀表达,前缀表达式都是由波兰数学家Jan Lukasiewicz提出来的 把运算符写在操作数之前,称为波兰表达式(Polish Expression)或前缀表达式(Prefix Expression),如+AB: 把运算符写在操作数之后,称为逆波兰表达式(Reverse Polish Expressio

[Leetcode] evaluate reverse polish notation 计算逆波兰表达式

Evaluate the value of an arithmetic expression in Reverse Polish Notation. Valid operators are+,-,*,/. Each operand may be an integer or another expression. Some examples: ["2", "1", "+", "3", "*"] -> (

续前篇-关于逆波兰表达式的计算

相对于逆波兰表达式的转换,逆波兰表达的计算可谓简单不少. 具体计算方法参考:http://www.cnblogs.com/vpoet/p/4659546.html 这里也大致梳理一下: 1.新建一个栈将逆波兰表达式的数字依次压入栈中 2.当遇到运算符时,出栈两个数同时将运算结果压栈 3.重复步骤2直到计算计算,栈中的元素即为逆波兰表达式的计算结果. 实现如下: 1 #include <iostream> 2 #include <stack> 3 using namespace st

【LeetCode刷题Java版】Evaluate Reverse Polish Notation(计算逆波兰表达式)

Evaluate the value of an arithmetic expression in Reverse Polish Notation. Valid operators are +, -, *, /. Each operand may be an integer or another expression. Some examples: ["2", "1", "+", "3", "*"] -&g

Java解析字符串表达式--逆波兰表达式的计算

问题来由: 读入一个字符串形式的四则运算表达式,输出对应的计算结果.如读入的是"6 * ( 5 + ( 2 + 3) * 8 + 3)",那么解析后的输出结果应为288. 思路: 一般的计算过程是这样的,首先计算优先级最高的小括号里面的内容,即"( 5 + ( 2 + 3) * 8 + 3)", 将"2 + 3"的计算结果并存为A,接着用计算"A*8",并存为B 计算"5+B+3",结果存为C 最后计算&q

JavaScript实现计算后缀表达式(逆波兰表达式)以及将中缀表达式转为后缀表达式

逆波兰表达式,它的语法规定,表达式必须以逆波兰表达式的方式给出.逆波兰表达式又叫做后缀表达式.这个知识点在数据结构和编译原理这两门课程中都有介绍,下面是一些例子: 正常的表达式 逆波兰表达式 a+b ---> a,b,+ a+(b-c) ---> a,b,c,-,+ a+(b-c)d ---> a,d,b,c,-,,+ a=1+3 ---> a=1,3 + http=(smtp+http+telnet)/1024 写成什么呢? http=smtp,http,telnet,+,+,1

栈的操作实现逆波兰表达式的计算

代码如下: #include <stdio.h> #include <stdlib.h> #include <ctype.h> #define STACK_INIT_SIZE 20 #define STACKINCREMENT 10 #define MAXBUFFER 10 typedef double ElemType; typedef struct { ElemType *base; ElemType *top; int StackSize; }sqStack; v