C++:表达式的计算

已于 2023-05-11 20:57:07 修改
阅读量1.2k 收藏 10
点赞数 1
分类专栏： 数据结构与算法基础（C++） 文章标签： 算法 数据结构 Powered by 金山文档
于 2023-03-25 10:14:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28414091/article/details/129763598
版权

一、后缀表达式的计算

#include<bits/c++.h>
using namespace std;

// 后缀表达式的计算

int main()
{
    stack<int> s;
    char cal[1000];
    
    cout << "输入后缀表达式：";
    cin >> cal;
    
    for (int i = 0; i < strlen(cal); i++)
    {
        if (cal[i] - '0' >= 0 && '9' - cal[i] >= 0)
        {
            s.push(cal[i] - '0');
        }    
        else
        {
            if (cal[i] == '+')
            {
                int back = s.top();
                s.pop(); 
                int front = s.top();
                s.pop();
                int result = front + back;
                s.push(result);
            }
            else if (cal[i] == '-')
            {
                int back = s.top();
                s.pop(); 
                int front = s.top();
                s.pop();
                int result = front - back;
                s.push(result);
            }
            else if (cal[i] == '*')
            {
                int back = s.top();
                s.pop(); 
                int front = s.top();
                s.pop();
                int result = front * back;
                s.push(result);
            }
            else if (cal[i] == '/')
            {
                int back = s.top();
                s.pop(); 
                int front = s.top();
                s.pop();
                int result = front / back;
                s.push(result);
            }
            else if (cal[i] == '%')
            {
                int back = s.top();
                s.pop(); 
                int front = s.top();
                s.pop();
                int result = front % back;
                s.push(result);
            }
        }
    }
    
    cout << "后缀表达式计算结果是：" << s.top() << endl;

        
    return 0;
}

/*
测试
234+*82/-
*/

二、中缀表达式的计算

需要一个操作数栈和一个运算符栈

定义计算操作

计算操作：操作数栈弹栈两次，运算符栈弹栈一次，进行相应的计算

扫描中缀表达式时遵循以下规则

  • 若扫描到操作数，直接进操作数栈，并继续扫描

  • 若扫描到运算符为 ( 、 * 、 /，直接进运算符栈，并继续扫描

  • 若扫描到运算符为 ) ，若栈顶运算符为+ 、- 、* 、/ ，进行计算操作，直至栈顶运算符为 ( ，停止计算，并运算符栈弹栈一次，继续扫描

  • 若扫描到运算符为+ 、- ，若运算符栈为空，直接进栈并继续扫描；若运算符栈顶为+ 、- 、( 直接进栈并继续扫描；若栈顶运算符为* 、/ ，进行计算操作，直至栈顶运算符不为* 、/，再将+ 、- 进栈并继续扫描

中缀表达式扫描完成以后

  • 若运算符栈为空，则中缀表达式的值则为操作数栈的栈顶元素

  • 若运算符栈不为空，进行计算操作，直至运算符栈为空，此时中缀表达式的值为操作数栈的栈顶元素

#include<bits/stdc++.h>
using namespace std;

// 中缀表达式的计算
// 以下代码仅适用于操作数为一位整数的情况

int main()
{
    stack<int> snum;
    stack<char> sop;
    char cal[1000];
    
    cout << "输入中缀表达式：";
    cin >> cal;
    
    for (int i = 0; i < strlen(cal); i++)
    {
        if (cal[i] - '0' >= 0 && '9'- cal[i] >= 0)
        {
            snum.push(cal[i] - '0');
        }
        else
        {
            if (cal[i] == '(')
            {
                sop.push(cal[i]);
            }
            else if (cal[i] == ')')
            {    
                while(sop.top() != '(')
                {
                    int num2 = snum.top();
                    snum.pop();
                    int num1 = snum.top();
                    snum.pop();
                    char op = sop.top();
                    sop.pop();
                    if (op == '+')
                    {
                        int num3 = num1 + num2;
                        snum.push(num3);    
                    }
                    else if (op == '-')
                    {
                        int num3 = num1 - num2;
                        snum.push(num3);
                    }
                    else if (op == '*')
                    {
                        int num3 = num1 * num2;
                        snum.push(num3);
                    }
                    else if (op == '/')
                    {
                        int num3 = num1 / num2;
                        snum.push(num3);
                    }
                }
                sop.pop();
            }
            else if (cal[i] == '+' || cal[i] == '-')
            {
                if (!sop.empty())
                {
                    while(sop.top() == '*' || sop.top() == '/')
                    {
                        int num2 = snum.top();
                        snum.pop();
                        int num1 = snum.top();
                        snum.pop();
                        char op = sop.top();
                        sop.pop();
                        if (op == '*')
                        {
                            int num3 = num1 * num2;
                            snum.push(num3);    
                        }
                        else if (op == '/')
                        {
                            int num3 = num1 / num2;
                            snum.push(num3);
                        }
                        if (sop.empty() || sop.top() == '(')
                            break;
                    }
                    sop.push(cal[i]);
                }
                else
                {
                    sop.push(cal[i]);
                }
            }
            else if (cal[i] == '*' || cal[i] == '/')
            {
                sop.push(cal[i]);
            }
        }
    }
    
    while(!sop.empty())
    {
        int num2 = snum.top();
        snum.pop();
        int num1 = snum.top();
        snum.pop();
        char op = sop.top();
        sop.pop();
        if (op == '+')
        {
            int num3 = num1 + num2;
            snum.push(num3);    
        }
        else if (op == '-')
        {
            int num3 = num1 - num2;
            snum.push(num3);
        }
        else if (op == '*')
        {
            int num3 = num1 * num2;
            snum.push(num3);
        }
        else if (op == '/')
        {
            int num3 = num1 / num2;
            snum.push(num3);
        }
    }
    
    cout << "中缀表达式计算结果是：" << snum.top() << endl;
        
    return 0;
}
/*
测试
2*(3+4)-8/2

(8*1+7*2)+(8/1-6/2)
*/

三、中缀表达式转换后缀表达式

中缀表达式转后缀表达式与中缀表达式的计算操作基本相同

只需要使用一个存储运算符的栈，操作数直接加入结果表达式中

运算符出栈的规律与计算时相同，但不用进行计算，只需要将出栈的运算符添加到表达式末尾

#include<bits/stdc++.h>
using namespace std;
 
// 中缀表达式转后缀表达式
// 以下代码仅适用于操作数为一位整数的表达式
 
int main()
{
    stack<char> sop;
    char cal[1000];
    
    cout << "输入中缀表达式：";
    cin >> cal;
    
    char back[1000];
    int index = 0;
    
    for (int i = 0; i < strlen(cal); i++)
    {
        if (cal[i] - '0' >= 0 && '9'- cal[i] >= 0)
        {
            back[index++] = cal[i];
        }
        else
        {
            // 若扫描到 (
            if (cal[i] == '(')
            {    
                sop.push(cal[i]);
            }
            // 若扫描到 * 或 /
            else if (cal[i] == '*' || cal[i] == '/')
            {    
                if (!sop.empty())
                {
                    if (sop.top() == '*' || sop.top() == '/')
                    {
                        back[index++] = sop.top();
                        sop.pop();
                    }
                }
                sop.push(cal[i]);
            }
            // 若扫描到 )
            else if (cal[i] == ')')
            {    
                while(sop.top() != '(')
                {
                    char op = sop.top();
                    sop.pop();
                    if (op == '+')
                    {
                        back[index++] = '+';    
                    }
                    else if (op == '-')
                    {
                        back[index++] = '-';
                    }
                    else if (op == '*')
                    {
                        back[index++] = '*';
                    }
                    else if (op == '/')
                    {
                        back[index++] = '/';
                    }
                }
                sop.pop();
            }
            // 若扫描到 + 或 -
            else if (cal[i] == '+' || cal[i] == '-')
            {
                if (!sop.empty())
                {
                    while(sop.top() == '*' || sop.top() == '/')
                    {
                        char op = sop.top();
                        sop.pop();
                        if (op == '*')
                        {
                            back[index++] = '*';    
                        }
                        else if (op == '/')
                        {
                            back[index++] = '/';
                        }
                        if (sop.empty() || sop.top() == '(')
                            break;
                    }
                    if (!sop.empty())
                    {
                        if (sop.top() == '+' || sop.top() == '-')
                        {
                            back[index++] = sop.top();
                            sop.pop();
                        }
                    }
                    sop.push(cal[i]);
                }
                else
                {
                    sop.push(cal[i]);
                }
            }
        }
    }
    
    while(!sop.empty())
    {
        char op = sop.top();
        sop.pop();
        if (op == '+')
        {
            back[index++] = '+';
        }
        else if (op == '-')
        {
            back[index++] = '-';
        }
        else if (op == '*')
        {
            back[index++] = '*';
        }
        else if (op == '/')
        {
            back[index++] = '/';
        }
    }
    
    cout << "转换成后缀表达式为：" << back << endl;
        
    return 0;
}
/*
测试
2*(3+4)-8/2
(8*1+7*2)+(8/1-6/2)
*/

西里都有的吗
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【c++】表达式计算
10-29
计算任意表达式（整数+-*/^)的结果。原理为带优先级的符号（括号内的算式优先级加三），然后优先级从大到小遍历
表达式计算C++
雪的期许
04-29 2187
问题描述 给定四则运算（含括号）表达式，计算运算结果。 拓展知识：逆波兰式。 样例输入 3+4*(5+6) 样例输出 47 问题分析 四则运算基本法则：先算乘除，后算加减，有括号的先算括号。于是给运算符定义优先级： 符号 优先级 + - 1 * / 2 由于括号实际上并不参与运算，只是改变运算的先后次序，所以括号不用考虑优先级，遇到括号时特判即可。 由于运算过程中，存在先算后面的情况，所以用栈来保存前面的运算符（如±），等后面运算（如*/）完成，再弹出栈中的运算符进行计算。这里的
c++基础知识——表达式
最新发布
asdfghjkl66hh的博客
07-05 689
C +＋语言中的表达式是由符合 C +＋语法规定的运算对象（包括常量、变量、函数调用传回的值等）、运算符、圆括号组成的有意义的算式。如 A +3.14159*5/8.4- abs (-1123)，式中 A 是一个常量． abs 是一个函数。
c++数学表达式计算
10-30
c++ 实现数学表达式计算 支持 常见的数学函数。如sin cos sqrt abs ... 支持 大多数运算符。 使用良好的设计模式，易于维护和拓展。
表达式计算（C++）
Taracake的博客
02-13 350
#include<iostream> #include<vector> #include<string> #include<stack> #include<cstdlib> using namespace std; /*判断符号间的优先关系函数 *1表示>,0表示=,-1表示< *c1栈内的算符，c2栈外的算符 */ int...
c++数学表达式解析
04-12
- **后缀表达式计算函数**：遍历后缀表达式，进行计算。 在C++中，可以使用标准库`std::stack`来实现栈，使用字符串流（`std::istringstream`）处理输入，以及利用`std::vector`存储后缀表达式。同时，为了处理负数...
C++期末：中缀表达式计算案例(详细注释)
05-07
实验名称:计算表达式 实验内容:设计一个程序，把中缀表达式转换成- -棵二叉树， 然后通过后根遍历计算表达式的值。 实验目的与要求:对于输入的一-个中缀表达式，判断表达式是否合法。如果合法，把中缀表达式转换成- ...
C++课程设计：表达式求值计算器
12-26
本项目以C++语言为工具，旨在提升学生的编程能力，理解和掌握表达式的解析与计算过程。以下是对该项目的详细解析。 首先，我们要理解C++的基础知识。C++是一种强大的、通用的面向对象编程语言，由Bjarne Stroustrup...
数学表达式计算c++
07-10
c++ 实现数学表达式计算 支持 常见的数学函数。如sin cos sqrt abs ... 支持 大多数运算符。 使用良好的设计模式，易于维护和拓展。
表达式计算（C++ STL 实现）
03-24
通过逆波兰式来计算数学中的中缀表达式，例如：3+(4-7*5)，主要是处理运算优先级问题。源码里面的注释非常详细，由于基于基本数据类型实现，实用价值较小，用作学习还是很不错的。（支持的符号（半角模式）：0123456789 ( ) .（小数点） + - * / !（阶乘） ^（次方））
c++计算表达式的值
11-17
自定义C++，非常有用的程序，输入算式就可得到结果
表达式计算c++（利用栈）
06-30
#include #include #include char OP[7]={'+','-','*','/','(',')','#'}; int In(char c){ int i; for(i=0;i<7;i++) if(c==OP[i]){return 1;break;} return 0; } int num(char e){ int i; for(i=0;i<7;i++){ if(e==OP[i]){ return i; break; } } }
[源码和报告分享]基于C++的表达式计算求值
11-29 171
功能要求 为了实现表达式求值，本项目要求首先读入表达式（包括括号）并创建对应二叉树，其次对二叉树进行前序遍历，中序遍历，后序遍历，输出对应的波兰表达式，中缀表达式和逆波兰表达式。 详细的开发文档和程序源代码我都分享在了个人博客上了，感兴趣的可以去看看： https://write-bug.com/article/1400.html ...
C++表达式计算
idelamadaqt的博客
03-01 2187
输入一串表达式，计算其结果。表达式包括数字'0'~'9'、'+'、'-'、'*'、'/'、'('、')'，并以符号'#'结尾。 在计算中，除法以向下取整计算。 保证表达式合法，且结果不超过long long范围。
表达式计算（C++实现）
zRegle的博客
03-09 3493
目前正在学习数据结构，根据书本上的思路自己捣鼓了一个表达式计算的小程序，目前支持负数、小数运算和报错。下面贴上代码，代码写的很烂（耦合度比较高，比较繁琐），大家如果有什么更好的建议可以提一下！PS：第一次写博客，诚惶诚恐#include <stack> #include <iostream> #include <string> //cin>>string #include <cstring> //s
C/C++之表达式计算
weixin_44575660的博客
04-24 1661
表达式计算 问题描述 　　输入一个只包含加减乖除和括号的合法表达式，求表达式的值。其中除表示整除。 输入格式 　　输入一行，包含一个表达式。 输出格式 　　输出这个表达式的值。 样例输入 1-2+3*(4-5) 样例输出 -4 数据规模和约定 　　表达式长度不超过100，表达式运算合法且运算过程都在int内进行。 #include<iostream> #include<stack...
表达式计算(C++版）
技术宅--火狼的专栏
12-07 8332
//虽然遇到了很多困难，但还是坚持了下来，用到了STL中的栈。 #include #include #include using namespace std; template void StackClear(stack &s) //清空栈 { while(!s.empty()) s.pop(); } /* 判断读取到的字符是否是运算符 */ int IsOperato
c++实现表达式计算问题
Loved_computer的博客
12-16 441
#include #include #include using namespace std; //栈的定义 template struct Node { T data; Node *next; }; template class LinkStack { public: LinkStack(); ~LinkStack(); T & GetTop();//获取
C++编程：表达式语句与系统软件可靠性
表达式语句是C++中的基本构成元素，它允许我们执行计算并控制程序流程。一条表达式语句由一个表达式（可选）后跟一个分号组成。表达式在执行后，会完成其副作用，例如变量赋值或函数调用，但不会引起迭代或控制流的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值