利用栈实现计算器，先转换为逆波兰式之后运算

最新推荐文章于 2020-04-19 23:50:26 发布
最新推荐文章于 2020-04-19 23:50:26 发布
阅读量464 收藏 1
点赞数
文章标签： 逆波兰 计算器 中缀转后缀
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzhustu/article/details/52900857
版权 
http://blog.csdn.net/liuzhustu/
#include <iostream>
#include<cstring>
#include<cstdlib>
#include<string>
#include <sstream>
#include <algorithm>
using namespace std;
class ArrayStackofInt{
private:
    int maxsize;
    int top;
    int *st;
public:
    ArrayStackofInt(int size)
    {
        maxsize=size;
        top=-1;
        st=new int [maxsize];
    }
    ArrayStackofInt()
    {
        top=-1;
    }
    ~ArrayStackofInt()
    {
        delete[] st;
    }
    void clear()
    {
        top=-1;
    }
    bool Push(const int item)
    {
        if(top==maxsize-1)
        {
            int *newSt=new int [maxsize*2];
            for(int i=0;i<=top;i++)
            {
                newSt[i]=st[i];
            }
            delete []st;
            st=newSt;
            maxsize *=2;
        }
        st[++top]=item;
        return true;
    }
    bool Pop(int & item)
    {
        if(top==-1)
        {
            cout<<"the stack is empty"<<endl;
            return false;
        }
        item=st[top--];
        return true;

    }
    bool Top(int & item)
    {
        if(top==-1)
        {
            cout<<"the stack is empty,No element can top"<<endl;
            return false;
        }
        item=st[top];
        return true;
    }
    };
class ArrayStackofChar{
private:
    int maxsize;
    int top;
    char *st;
public:
    ArrayStackofChar(int size)
    {
        maxsize=size;
        top=-1;
        st=new char[maxsize];
    }
    ArrayStackofChar()
    {
        top=-1;
    }
    ~ArrayStackofChar()
    {
        delete[] st;
    }
    void clear()
    {
        top=-1;
    }
    bool Push(const char item)
    {
        if(top==maxsize-1)
        {
            char* newSt=new char [maxsize*2];
            for(int i=0;i<=top;i++)
            {
                newSt[i]=st[i];
            }
            delete []st;
            st=newSt;
            maxsize *=2;
        }
        st[++top]=item;
        return true;
    }
    bool Pop(char & item)
    {
        if(top==-1)
        {
            cout<<"the stack is empty"<<endl;
            return false;
        }
        item=st[top--];
        return true;

    }
    bool Top(char & item)
    {
        if(top==-1)
        {
            cout<<"the stack is empty"<<endl;
            return false;
        }
        item=st[top];
        return true;
    }
    bool IsEmpty()
    {
        return top==-1;
    }
};
ArrayStackofChar op(10);
ArrayStackofInt  number(10);
class Calculator{
public:
    double calculate(string InfixExp);
    string infix_suffix(string InfixExp);
    double cal_suffix(string PostfixExp);
    double cal(double num1,double num2,char op);
};
double Calculator::calculate(string InfixExp)
{
    string PostfixExp=infix_suffix(InfixExp);
    return cal_suffix(PostfixExp);
}
double Calculator::cal_suffix(string PostfixExp)
{   cout<<PostfixExp<<endl;
    int i=0;
    int num1;
    int num2;
    int result;
    while(PostfixExp[i]!='\0')
    {
        switch(PostfixExp[i])
        {
            case '1':
                {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;

                    cout<<result<<endl;

                    number.Push(result);
                    break;
                }
            case '2':
                {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;
                    cout<<result<<endl;
                    number.Push(result);
                    break;
                }

            case '3':
                {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;
                    cout<<result<<endl;
                    number.Push(result);
                    break;
                }

            case '4':
               {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;
                    cout<<result<<endl;
                    number.Push(result);
                    break;
                }
            case '5':
               {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;
                    number.Push(result);
                    break;
                }
            case '6':
                {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;
                    number.Push(result);
                    break;
                }
            case '7':
                {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;
                    number.Push(result);
                    break;
                }
            case '8':
                {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;
                    number.Push(result);
                    break;
                }
            case '9':
                {   string num;
                    while(PostfixExp[i]>=48&&PostfixExp[i]<=57)
                    {
                       num+=PostfixExp[i];
                       i++;
                    }
                    stringstream ss;
                    ss<<num;
                    ss>>result;
                    cout<<result<<endl;
                    number.Push(result);
                    break;
                }
            case '+':
            {
                number.Pop(num1);
                number.Pop(num2);
                result=cal(num1,num2,'+');
                number.Push(result);

                break;
            }
            case '-':
            {
                number.Pop(num2);
                number.Pop(num1);
                result=cal(num1,num2,'-');
                number.Push(result);
                break;
            }
            case '*':
            {
                number.Pop(num1);
                number.Pop(num2);
                result=cal(num1,num2,'*');
                number.Push(result);
                break;
            }
            case '/':
           {
                number.Pop(num2);
                number.Pop(num1);
                result=cal(num1,num2,'/');
                number.Push(result);
                break;
            }

        }

        i++;
    }
    //number.Top(result);
    cout<<"num1 "<<num1<<" num2 "<<num2<<endl;
    return result;
}
string Calculator::infix_suffix(string InfixExp)
{
    int i=0;
    string PostfixExp;
    while(InfixExp[i]!='\0')
    {
        switch(InfixExp[i])
        {
            case '1':
                PostfixExp+=InfixExp[i];
            break;
            case '0':
                PostfixExp+=InfixExp[i];
            break;
            case '2':
                PostfixExp+=InfixExp[i];
            break;
            case '3':
                PostfixExp+=InfixExp[i];
            break;
            case '4':
                PostfixExp+=InfixExp[i];
            break;
            case '5':
                PostfixExp+=InfixExp[i];
            break;
            case '6':
                PostfixExp+=InfixExp[i];
            break;
            case '7':
                PostfixExp+=InfixExp[i];
            break;
            case '8':
                PostfixExp+=InfixExp[i];
            break;
            case '9':
                PostfixExp+=InfixExp[i];
            break;
            case '(':
                {
                     PostfixExp+=" ";
                     op.Push(InfixExp[i]);
                     break;
                }
            case ')':
               {

                PostfixExp+=" ";
                char temp;
                op.Top(temp);
                if(op.IsEmpty())
                {
                    op.clear();//此处抛异常
                    break;
                }
                while(temp!='(')
                {   op.Pop(temp);
                    PostfixExp+=temp;
                    op.Top(temp);

                }
                if(temp=='(')
                {
                    op.Pop(temp);
                }
                if(op.IsEmpty())
                    {
                        op.clear();//此处抛异常
                        break;
                    }
                break;
                }
            case '+':
                {
                    PostfixExp+=" ";
                    char temp=' ';
                    if(!op.IsEmpty())
                    {
                        op.Top(temp);
                    }
                    while(!op.IsEmpty()&&temp!='(')
                    {   op.Pop(temp);
                        PostfixExp+=temp;
                        if(!op.IsEmpty())
                        {
                          op.Top(temp);
                        }
                    }

                    op.Push(InfixExp[i]);
                    break;
                }
                case '-':
                {
                    PostfixExp+=" ";
                    char temp=' ';
                    if(!op.IsEmpty())
                    {
                        op.Top(temp);
                    }
                    while(!op.IsEmpty()&&temp!='(')
                    {   op.Pop(temp);
                        PostfixExp+=temp;
                        op.Top(temp);
                    }
                    op.Push(InfixExp[i]);
                    break;
                }
                case '*':
                {
                    PostfixExp+=" ";
                    char temp=' ';
                    if(!op.IsEmpty())
                    {
                        op.Top(temp);
                    }
                     while(!op.IsEmpty()&&temp!='('&&(temp=='*'||temp=='/'))
                    {   op.Pop(temp);
                        PostfixExp+=temp;
                        op.Top(temp);
                    }
                    op.Push(InfixExp[i]);
                    break;
                }
                case '/':
                {
                    PostfixExp+=" ";
                    char temp=' ';
                    if(!op.IsEmpty())
                    {
                        op.Top(temp);
                    }
                     while(!op.IsEmpty()&&temp!='('&&(temp=='*'||temp=='/'))
                    {   op.Pop(temp);
                        PostfixExp+=temp;
                        op.Top(temp);
                    }
                    op.Push(InfixExp[i]);
                    break;
                }


        }
        i++;
    }
    if(!op.IsEmpty())
    {
        char temp=' ';
        string rev;
        while(!op.IsEmpty()&&temp!='(')
        {   PostfixExp+=" ";
            op.Pop(temp);
           rev+=temp;
        }
      // reverse(rev.begin(),rev.end());

    PostfixExp+=rev;
    }
    return PostfixExp;
}
double Calculator::cal(double num1,double num2,char op)
{
    if(op=='+')
    {
        return num1+num2;
    }
    if(op=='-')
    {
        return num1-num2;
    }
    if(op=='*')
    {
        return num1*num2;
    }
    if(op=='/')
    {   if(num2==0)
        {
            cout<<"num2==0,Exception"<<endl;
            return 0;
        }
        return num1/(num2*1.0);
    }
}

int main()
{
    Calculator c;
    double d=c.calculate("(5*6)-2+3*2/2+（1*1）");
    cout<<d<<endl;

    return 0;
}
Transcend2022
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
利用堆栈实现波兰表达式实现后缀表达式计算
09-01
C++语言，利用堆栈实现波兰表达式实现后缀表达式计算。
逆波兰计数器（用堆栈实现逆波兰计算器）
12-08
主要是用堆栈实现逆波兰计算器，对于初学者来说是不错的资源
逆波兰式表达式计算引擎
11-10
逆波兰式表达式计算引擎 ReversePolishExpression Tool V1.0.1 Feature 1.Attention! the input expression isn't allowed to constants Invalid Characters like '_、#' 2.It's supported the calculation of div(/) mod(%) sqrt(_) mul(*) sub(-) pow(^) 3.The Usage: there is needly two HashMap<String,Object> .One as the input paramters and another was put into the first HashMap for passing the expression's values.The parent HashMap contains lots of placeholders, just like the 'AA'、'BB'、'CC' see the example code below. eg. HashMap<String,Object> maps = new HashMap<String,Object>(); HashMap<String,Object> kvmap = new HashMap<String,Object>(); maps.put("expression", "(((AA*-BB)*CC+(AA*-BB)/CC)+((AA*(-BB))*CC+(AA*-BB)%CC))"); kvmap.put("AA", 4); kvmap.put("BB", 2); kvmap.put("CC", 9); maps.put("kvmap", kvmap); System.out.println("使用工具结果："+ReversePolishExpression.calculateExpression(maps));
栈实现逆波兰计算器（后缀表达式）
a804847944的博客
09-27 302
逆波兰计算器 　　设计一个逆波兰计算器，可以完成如下任务： 　　　（1）输入一个逆波兰表达式（后缀表达式），使用栈（stack），计算其结果。 　　　（2）支持小括号和多位数整数。 　　　（3）思路分析 　　　　　　从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到...
算法--堆栈应用（逆波兰式与四则运算求值实现）
weixin_34279579的博客
10-07 877
逆波兰式 http://www.cnblogs.com/youxin/archive/2012/07/30/2615716.html 逆波兰式也叫后缀表达式（postfix）(将运算符写在操作数之后)，相应的波兰表达式叫前缀表达式（运算符在操作数之前）。 中缀表达式（infix）是我们最常使用的。 如：我们平时写a+b，这是中缀表达式，写成后缀表达式就是：ab+ 四则运算求值 ...
counter_逆波兰式_对数运算_
09-30
逆波兰式计算器，支持加减乘除，乘方开方，三角函数，反三角函数，指数对数运算
逆波兰运算计算器
08-12
包括表达式容错处理，正常的数的加减乘除，
逆波兰式计算器
06-15
逆波兰式完整代码计算器，带注释可直接运行VS2013，测试数据"1.0+3/2-tan(45)/(1+1)"，
C++使用逆波兰表达式实现计算器四则运算（完整代码）
04-10
使用C++模拟了计算器的四则运算，包括加减乘除以及括号优先级运算，主要解决办法是将键盘输入的四则运算表达式转为逆波兰表达式，然后再进一步计算逆波兰表达式的值，具体算法思路在主页，资源包括一个main.cpp文件...
基于逆波兰式计算器
04-02
基于VS和MFC的计算器，拥有良好图像界面，实现多位数，多项式数值计算
C++逆波兰表达式转化实现简单计算器
hahazhangyu0310的博客
07-28 1778
使用C++模版实现一个模版栈，并将中缀字符串计算式转化为逆波兰表达式，实现一个简单计算器功能。计算器有 + - * / ，支持负号，不支持小数，数字范围为 int 类型的取值范围。 下面为代码： stack_template.h #ifndef _MY_STACK_H #define _MY_STACK_H #include template struct stackNode { T
java实现逆波兰式算法（方程式运算）
iteye_1154的博客
11-21 429
感谢这位原文网友，原文来自http://blog.csdn.net/yunxiang/article/details/1918717 代码不多只有三个类，第一个是对象类，第二个是解析类（主类，外面就用这个类的接口），第三个是计算类 package expression1; import java.util.*; //栈类 public class Stacks { ...
表达式计算器（逆波兰法）栈操作（C语言实现）
热门推荐
Zxn、Sirius荣耀之路
04-07 1万+
可能很多的同学在学数据结构的时候。说到栈，都会有一道很经典的题目，那就是用栈来实现计算器。我们都知道普通的计算写起来是很简单的，但是如果涉及到左右括号以及加减乘除组成的运算式的时候则写起程序时便不那么容易了。 比如：（1+（2*（1+3）/2）+10) 面对上面这个表达式，要想写出这样一个计算器的程序就显得比较困难，有一种先进后出的数据结构———栈就可以很好的解决这个问题。那么是不是我们有了栈之
栈内链表&用后缀完成计算器功能
GX0401的博客
08-08 241
正常的表达式         逆波兰表达式  a+b ---&gt;a,b,+ a+(b-c) ---&gt; a,b,c,-,+ a+(b-c)*d ---&gt; a,b,c,-,d,*,+ a+d*(b-c)---&gt;a,d,b,c,-,*,+ a=1+3 ---&gt; a,1,3,+,= 它的优势在于只用两种简单操作，入栈和出栈就可以搞定任何普通表达式的运算。其运算方式如...
Python实现栈，以及利用栈来实现文件的深度优先遍历、利用栈计算逆波兰式的值，实现有min方法的栈
qq542793678的博客
05-03 288
Python实现的方法有很多种，这里就用列表来实现 栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。 栈的特性：后进先出或先进后出。 一、定义一个栈类（Python3实现） class Inn: def __init__(self): self.__inn = [] # 进栈 def push(self, item): ...
Python3实现逆波兰表达式计算
JsonD的专栏
05-01 1931
Python3实现逆波兰表达式计算
计算逆波兰式（后缀表达式）的值——栈的使用
Woosual的博客
02-01 789
s.empty(); //如果栈为空则返回true, 否则返回false; s.size(); //返回栈中元素的个数 s.top(); //返回栈顶元素, 但不删除该元素 s.pop(); //弹出栈顶元素, 但不返回其值 s.push(); //将元素压入栈顶 题目描述 计算逆波兰式（后缀表达式）的...
利用栈实现逆波兰表达式的转换与计算
qq_37879809的博客
06-14 246
import java.util.Scanner; import java.util.Stack; public class Calculator { //中序表达式转后续 private static Stack<Character> interfixToSuffix(String expression) { Stack<Chara...
计算逆波兰式的值(用到栈)
weixin_41613698的博客
04-19 244
问题描述 计算逆波兰式（后缀表达式）的值 运算符仅包含"+","-","“和”/"，被操作数可能是整数或其他表达式 例如： [“2”, “1”, “+”, “3”, ""] -> ((2 + 1) * 3) -> 9↵ [“4”, “13”, “5”, “/”, “+”] -> (4 + (13 / 5)) -> 6 分析 逆波兰式简单来说就是将操作符放到数值的后面的表...
c语言用栈实现计算器加法运算,(转)利用栈实现模拟计算器
最新发布
06-01
下面是一个基于栈的C语言计算器加法运算实现的示例代码： ```c #include #include #define MAX_SIZE 100 typedef struct stack { int top; // 栈顶指针 int data[MAX_SIZE]; // 栈的数组 } Stack; // 初始化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值