HJ50-四则运算：栈的运用、中缀表达式转后缀表达式并计算结果

已于 2024-09-28 17:37:34 修改
阅读量61 收藏
点赞数
分类专栏： 笔试刷题案例分析 文章标签： 算法
于 2024-09-28 17:33:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TxyITxs/article/details/142617439
版权

文章目录

题目

在这里插入图片描述

一、分析

通过利用栈将中缀表达式转换为后缀表达式，在根据后缀表达式计算运算结果。由于包含负数操作数的情况，并且操作数位数不固定为1，因此，需要对输入的表达式进行预处理，将操作数和操作符进行分离，并且将大括号和中括号统一为小括号。

1.1表达式预处理

/// <summary>
/// 预处理表达式
/// </summary>
/// <param name="data">中缀表达式</param>
/// <returns>表达式</returns>
std::vector<std::string>  pretreat(const std::string& data)
{
		std::string value = data;
		//->处理括号
		for (int i = 0; i < value.size(); i++)
		{
				if (value[i] == '[' || value[i] == '{') value[i] = '(';
				if (value[i] == ']' || value[i] == '}') value[i] = ')';
		}
		//->处理负数,并将运算符与运算数拆分开
		value = '(' + value + ')';	
		int index = -1;
		std::vector<std::string> content;
		for (int i = 0; i < value.size(); i++)
		{
				//->负数操作数的情况
				if (value[i] == '-' && (i - 1) >= 0 && value[i - 1] == '(' && (i + 1) < value.size() && value[i + 1] >= '0' && value[i + 1] <= '9')
				{
						index = i;
						continue;
				}
				//->非负数操作数
				else if (value[i] >= '0' && value[i] <= '9' && index == -1)
				{
						index = i;
				}
				if ((value[i] < '0' || value[i] > '9') && index != -1)
				{
						content.push_back(value.substr(index, i - index));
						index = -1;
				}
				if ((value[i] < '0' || value[i] > '9') && index == -1)
				{
						content.push_back(value.substr(i, 1));
				}
		}
		return content;
}

1.2中缀表达式转后缀

1.2.1 对于中缀表达式A+B*(C-D)-E/F转后后缀表达式时，栈中数据变化情况如下。

1.2.2 栈内和栈外操作符的优先级如下。

std::map<std::string, int> isp = { {"#",0}, {"(",1},  {"*",5},  {"/",5},  {"+",3},  {"-",3},  {")",6} };//->栈内操作符的优先级
std::map<std::string, int> icp = { {"#",0}, {"(",6},  {"*",4},  {"/",4},  {"+",2},  {"-",2},  {")",1} };//->栈外操作符的优先级

1.2.3 代码逻辑伪代码如下，可根据此变化设计代码逻辑。

步扫描项项类型动作栈变化输出
0“#”进栈#
1A操作数#A
2+操作符isp[“#”] < icp[“+”],进栈#+A
3B操作数#+AB
4*操作符isp[“+”] < icp[“*”],进栈#+*AB
5(操作符isp[“*”] < icp[“(”],进栈#+*(AB
6C操作数#+*(ABC
7-操作符isp[“(”] < icp[“-”],进栈#+*(-ABC
8D操作数#+*(-ABCD
9)操作符isp[“-”] >icp[“)”],退栈#+*(ABCD-
”(“ == “)”,退栈#+*ABCD-
10-操作符isp[“*”] > icp[“-”],退栈#+ABCD-*
isp[“+”] > icp[“-”],退栈#ABCD-*+
isp[“#”] < icp[“-”],进栈#-ABCD-*+
11E操作数#-ABCD-*+E
12/操作符isp[“-”] < icp[“/”],进栈#-/ABCD-*+E
13F操作数#-/ABCD-*+EF
14#操作符isp[“/”] > icp[“#”],退栈#-ABCD-*+EF/
操作符isp[“-”] > icp[“#”],退栈#ABCD-*+EF/-
结束
/// <summary>
/// 判断是否是操作数
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
bool isDigit(std::string& value)
{
		if (value.empty())
				return false;
		return value.back() >= '0' && value.back() <= '9';
}

/// <summary>
/// 将中缀表达式转换为后缀表达式
/// </summary>
/// <param name="data">中缀表达式</param>
/// <returns>后缀表达式</returns>
std::vector<std::string> postfix(std::vector<std::string>& content)
{
		//->定义栈内操作符和栈外操作符的优先级
		std::map<std::string, int> isp = { {"#",0}, {"(",1},  {"*",5},  {"/",5},  {"+",3},  {"-",3},  {")",6} };//->栈内操作符的优先级
		std::map<std::string, int> icp = { {"#",0}, {"(",6},  {"*",4},  {"/",4},  {"+",2},  {"-",2},  {")",1} };//->栈外操作符的优先级
		content.push_back("#");

		int index = 0;
		std::vector<std::string> expression;
		std::string item1 = "#", item2, item3;
		std::stack<std::string> stack;
		stack.push(item1);
		item1 = content[index];
		index++;

		while (!stack.empty() && item1 != "#")
		{
				if (isDigit(item1))
				{
						expression.push_back(item1);
						item1 = content[index];
						index++;
				}
				else
				{
						item2 = stack.top();
						if (isp[item2] < icp[item1])
						{
								stack.push(item1);
								item1 = content[index];
								index++;
						}
						else if (isp[item2] > icp[item1])
						{
								expression.push_back(stack.top());
								item3 = stack.top();
								stack.pop();
						}
						else
						{
								std::string item = stack.top();
								stack.pop();
								if (item == "(")
								{
										item1 = content[index];
										index++;
								}
						}
				}
		}
		return expression;
}

1.3 后缀表达式计算结果

1.3.1 计算后缀表达式ABCD-*+EF/-栈中元素变化情况，逻辑如下。

步扫描项项类型动作栈中内容
1栈置空空
2A操作数进栈A
3B操作数进栈AB
4C操作数进栈ABC
5D操作数进栈ABCD
6-操作符D、C退栈，计算C-D，结果R1进栈ABR1
7*操作符R1、B退栈，计算B*R1，结果R2进栈BR2
8+操作符R2、B退栈，计算A+R2，结果R3进栈R3
9E操作数进栈R3E
10F操作数进栈R3EF
11/操作符F、E退栈，计算E/F，结果R4进栈R3R4
12-操作符R4、R3退栈。计算R3-R4，结果R5进栈R5
/// <summary>
/// 根据后缀表达式计算结果
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
float calculator(std::vector<std::string>& expression)
{
		std::stack<float> values;
		for (int i = 0; i < expression.size(); i++)
		{
				std::string value = expression[i];
				if (isDigit(value))
				{
						values.push(std::atoi(value.c_str()));
				}
				else
				{
						float value1 = values.top(); values.pop();
						float value2 = values.top(); values.pop();
						switch (value[0])
						{
						case '+': values.push(value2 + value1); break;
						case '-':  values.push(value2 - value1); break;
						case '*': values.push(value2 * value1); break;
						case '/': values.push(value2 / value1); break;
						default:break;
						}
				}
		}
		return values.top();
}

二、答案

#include  <iostream>
#include <stack>
#include <string>
#include <vector>
#include <map>

/// <summary>
/// 判断是否是操作数
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
bool isDigit(std::string& value)
{
		if (value.empty())
				return false;
		return value.back() >= '0' && value.back() <= '9';
}

/// <summary>
/// 将中缀表达式转换为后缀表达式
/// </summary>
/// <param name="data">中缀表达式</param>
/// <returns>后缀表达式</returns>
std::vector<std::string> postfix(std::vector<std::string>& content)
{
		//->定义栈内操作符和栈外操作符的优先级
		std::map<std::string, int> isp = { {"#",0}, {"(",1},  {"*",5},  {"/",5},  {"+",3},  {"-",3},  {")",6} };//->栈内操作符的优先级
		std::map<std::string, int> icp = { {"#",0}, {"(",6},  {"*",4},  {"/",4},  {"+",2},  {"-",2},  {")",1} };//->栈外操作符的优先级
		content.push_back("#");

		int index = 0;
		std::vector<std::string> expression;
		std::string item1 = "#", item2, item3;
		std::stack<std::string> stack;
		stack.push(item1);
		item1 = content[index];
		index++;

		while (!stack.empty() && item1 != "#")
		{
				if (isDigit(item1))
				{
						expression.push_back(item1);
						item1 = content[index];
						index++;
				}
				else
				{
						item2 = stack.top();
						if (isp[item2] < icp[item1])
						{
								stack.push(item1);
								item1 = content[index];
								index++;
						}
						else if (isp[item2] > icp[item1])
						{
								expression.push_back(stack.top());
								item3 = stack.top();
								stack.pop();
						}
						else
						{
								std::string item = stack.top();
								stack.pop();
								if (item == "(")
								{
										item1 = content[index];
										index++;
								}
						}
				}
		}
		return expression;
}

/// <summary>
/// 预处理表达式
/// </summary>
/// <param name="data">中缀表达式</param>
/// <returns>表达式</returns>
std::vector<std::string>  pretreat(const std::string& data)
{
		std::string value = data;
		//->处理括号
		for (int i = 0; i < value.size(); i++)
		{
				if (value[i] == '[' || value[i] == '{') value[i] = '(';
				if (value[i] == ']' || value[i] == '}') value[i] = ')';
		}
		//->处理负数,并将运算符与运算数拆分开
		value = '(' + value + ')';	
		int index = -1;
		std::vector<std::string> content;
		for (int i = 0; i < value.size(); i++)
		{
				//->负数操作数的情况
				if (value[i] == '-' && (i - 1) >= 0 && value[i - 1] == '(' && (i + 1) < value.size() && value[i + 1] >= '0' && value[i + 1] <= '9')
				{
						index = i;
						continue;
				}
				//->非负数操作数
				else if (value[i] >= '0' && value[i] <= '9' && index == -1)
				{
						index = i;
				}
				if ((value[i] < '0' || value[i] > '9') && index != -1)
				{
						content.push_back(value.substr(index, i - index));
						index = -1;
				}
				if ((value[i] < '0' || value[i] > '9') && index == -1)
				{
						content.push_back(value.substr(i, 1));
				}
		}
		return content;
}

/// <summary>
/// 根据后缀表达式计算结果
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
float calculator(std::vector<std::string>& expression)
{
		std::stack<float> values;
		for (int i = 0; i < expression.size(); i++)
		{
				std::string value = expression[i];
				if (isDigit(value))
				{
						values.push(std::atoi(value.c_str()));
				}
				else
				{
						float value1 = values.top(); values.pop();
						float value2 = values.top(); values.pop();
						switch (value[0])
						{
						case '+': values.push(value2 + value1); break;
						case '-':  values.push(value2 - value1); break;
						case '*': values.push(value2 * value1); break;
						case '/': values.push(value2 / value1); break;
						default:break;
						}
				}
		}
		return values.top();
}

int main()
{
		std::string data;
		std::cin >> data;
		std::vector<std::string> content = pretreat(data);
		std::vector<std::string> expression = postfix(content);
		std::cout << calculator(expression);
		return 0;
}
秘境之眼
关注
专栏目录
java正则表达式去除xml标签之间的空格_这个教程，真的让我学会了正则表达式
weixin_39611820的博客
11-22 723
这是一篇翻译文章。我学过很多次正则表达式，总是学了忘，忘了学，一到用的时候还是只能靠搜索引擎。 这回看到这个正则教程，感觉非常惊喜。尝试翻译了一遍，译得不好，大家可以看原文，很容易理解。 原文地址：https://refrf.shreyasminocha.me/1 介绍正则表达式允许定义一种模式，并通过这种模式针对字符串执行对应的操作。与模式匹配的子字符串称为“匹配”。 正则表达式是定义搜索模...
中缀表达式转后缀表达式+四则运算编程-华为机试HJ50
qq_40259429的博客
04-18 517
1、中缀表达式转后缀表达式 在编程实现四则运算时，往往需要两个步骤：（1）将题目给的中缀表达式转为后缀表达式；（2）利用后缀表达式进行计算； 对于1+（2-3）*4+10/5 准备一个栈用于存放符号，对于数字就输出，对于符号A，如果A的优先级大于栈内符号，那么A就入栈，如果栈内没有比A优先级小的符号，那么栈内的符号就出栈，再把A入栈。对于括号就入栈，一直匹配到右括号再将括号里的符号出栈。另外，还需要把表达式的[]{}这些符号要提前转化为（）。 1、输出1，+入栈，此时后缀表达式是1 2、此时遇到左括
刷题：华为机试 HJ50 中缀表达式转换为后缀表达式的四则运算
会编程的大厨的博客
04-14 530
中缀表达式利于我们手动计算，对于计算机而言，后缀表达式更利于计算机计算。 那么，如何将中缀表达式转换为后缀表达式，按照以下步骤即可。 ①按照运算符的优先级对所有运算符和它的运算数加括号（原本有括号的就不用再加了） ②把运算符移动到对应的括号后 ③去掉括号 同样的，将中缀表达式转化为前缀表达式，与上述过程类似： ①按照运算符的优先级对所有运算符和它的运算数加括号（原本有括号的就不用再加了） ②把运算符移动到对应的括号前 ③去掉括号 ...
华为OD机考题(HJ50 四则运算)
磐门的博客
07-03 776
经过前期的数据结构和算法学习，开始以OD机考题作为练习题，继续加强下熟练程度。
牛客题目HJ50（四则运算）
MFL_xiaotaiye的博客
09-21 542
牛客题目HJ50（四则运算）
HJ54表达式求值【pyhon3】
Yorusimo的博客
02-15 458
华为牛客机试HJ54
基于QT实现的计算器（只需要简单的栈知识，不仅仅是四则运算，接近手机内置计算器功能）
qq_42181309的博客
06-27 1508
参考文献：Qt 5.9 C++开发指南 (王维波等 著)及众多网上资料 1.问题定义及需求分析 课题目的： 由输入的四则算术表达式字符串，动态生成算术表达式所对应的后缀式，通过后缀式求值并输出； 输出的形式：界面上：以QT中的Text Browser进行输出结果。后台：通过suffix文件输出表达式的后缀表达式。 程序的功能：在布局和功能上，我们以小米内置计算器为标准。在运算上：我们实现...
逆波兰表达式_四则表达式
ryontang的博客
09-03 198
1. 逆波兰表达式实现的四则运算 2. 如何把中缀表达式转换为后缀表达式
C/C++项目之大数据的加减乘除求模以及括号四则运算
hj605635529的博客
05-04 1733
BigData.h #pragma once #include #include using namespace std; #include #include typedef long long INT64; class BigData { public: BigData(INT64 value); BigData(const string & strData); friend
C++利用栈实现中缀表达式转后缀表达式
12-20
在计算机科学中，中缀表达式是我们日常生活中最常见的表达式形式，例如...总的来说，通过这个实例，我们可以了解到如何在C++中利用栈来解决实际的计算问题，加深了对栈数据结构和中缀表达式转后缀表达式算法的理解。
自定义栈中缀表达式转换为后缀表达式并求值
05-20
`stack`用于管理运算符的顺序和优先级，`Middle_expressionToPost_expression`负责中缀表达式到后缀表达式的转换，而`Post_expression_value`则用于解析后缀表达式并计算其结果。 #### 存储结构 - **栈**: 逻辑...
「Java 数据结构和算法」：图文详解---中缀表达式转后缀表达式。_中缀表达式转后缀表达式流程图
2401_84185951的博客
04-28 936
栈是⼀个先⼊后出的有序列表。栈(stack)是限制线性表中元素的插⼊和删除只能在线性表的同⼀端进⾏的⼀种特殊线性表。允许插⼊和删除的⼀端，为变化的⼀端，称为栈顶(Top)，另⼀端为固定的⼀端，称为栈底(Bottom)。根据栈的定义可知，最先放⼊栈中元素在栈底，最后放⼊的元素在栈顶，⽽删除元素刚好相反，最后放⼊的元素最先删除，最先放⼊的元素最后删除。
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 422
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1063
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
python 实现harmonic series调和级数算法
luthane的博客
09-24 941
Hn∑k1n1kHn​k1∑n​k1​其中，𝑛n 是正整数。这个级数是由调和数列（Harmonic sequence）的各元素相加所得的和。调和级数的名字源于泛音及泛音列，即一条振动的弦的泛音的波长依次是基本波长的12131421​31​41​等。调和级数的性质发散性：调和级数是一个发散的无穷级数，也就是说，它的部分和随着项数的增加而无限增长。
算法分类&自动驾驶主要算法介绍
joanna_xiao的博客
09-28 222
基础算法用于支持在设计程序和编写代码的过程中进行最基本的技术逻辑管理。常用的基础算法有快速排序算法、堆排序算法、归并排序、二分查找算法、BFPRT（线性查找算法）、DFS(深度优先搜索）、BFS(广度优先搜索）、Dijkstra算法、动态规划算法、朴素贝叶斯分类算法等。常见的行业算法如无人驾驶，AI医疗诊断，配送路径规划、工业检测、城市管理中的问题发展与预测、犯罪行为识别与预警等。常用的通用算法有视频处理、图像识别、目标检测、人流统计、行为识别、人脸识别、自然语言处理等。自动驾驶主要算法介绍。
算法宝典——二分查找算法
最新发布
2301_80689220的博客
09-28 98
初识算法之二分查找
560. 和为 K 的子数组
mrjieke6的博客
09-24 283
子数组是数组中元素的连续非空序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

秘境之眼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值