数据结构3、基于栈的后缀算术表达式求值

BraveTomato2024-01-30 11:40

1 题目描述

图1 中缀表达式转化为后缀表达式题目描述
图2 基于栈的后缀算术表达式求值题目描述

2 题目解读

借助一个运算符栈，可将中缀表达式转化为后缀表达式；借助一个运算数栈，可对后缀表达式求值。借助一个运算符栈和一个运算数栈，则可将中缀表达式转化为后缀表达式输出，并根据后缀表达式计算。

3 小题一：中缀表达式转化为后缀表达式

借助一个运算符栈，则可以将中缀表达式转化为后缀表达式。

3.1 解题思路

为实现中缀表达式转换成后缀表达式，可以使用一个工作栈OPTR 寄存运算符，初始化为空栈；使用一个字符串Postfix寄存转换得到的后缀表达式，初始化为空串。具体步骤如下。

（1）初始化OPTR 栈，将表达式起始符"#"压入OPTR栈。

（2）扫描表达式，读入第一个字符ch ，如果表达式没有扫描完毕至"="或OPTR的栈顶元素不为"#"时，则循环执行以下操作。

  • 若ch 不是运算符，则加入字符串Postfix。
  • 若ch 是运算符，则根据OPTR 的栈顶元素和ch的优先级比较结果，进行以下不同的处理。

a.若是小于，则ch 压入OPTR 栈，读入下一字符ch。

b.若是大于，则弹出OPTR 栈顶的运算符，加入字符串Postfix。

c.若是等于，则OPTR 的栈顶元素是"("且ch 是")"，这时弹出OPTR 栈顶的"("，相当于括号匹配成功，然后读入下一字符ch。

（3）字符串Postfix中的元素即为后缀表达式，返回后缀表达式。

3.2 设计代码

cpp 复制代码 
#include <iostream>
#include <iomanip>
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
#define OVERFLOW -2
//------顺序栈的存储结构------
#define MAXSIZE 100  //顺序栈存储空间的初始分配量
typedef char SElemType;
typedef struct
{
	SElemType *base; //栈底指针
	SElemType *top;  //栈顶指针
	int stacksize;   //栈可用的最大容量
}SqStack;
//Status是函数返回值类型，其值是函数结果状态代码
typedef int Status;
Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
SElemType GetTop(SqStack S);
//表达式求值相关算法
bool In(SElemType ch);
SElemType Precede(SElemType optr, SElemType ch);
//中缀表达式转化为后缀表达式
string ztoh(char ch);
int main() {
	char ch;
	while (true) {
		cin >> ch;
		if ('=' == ch) {
			break;
		}
		string res = ztoh(ch);
		cout << res << endl;
	}
	return 0;
}
string ztoh(char ch)
{
	SqStack OPTR;
	InitStack(OPTR);
	Push(OPTR, '#');
	string Postfix = "";
	//表达式未读完 或 OPTR栈有运算符
	while (ch != '=' || GetTop(OPTR) != '#')
	{
		if (!In(ch)) {
			Postfix.push_back(ch);
			cin >> ch;
		}
		else {
			switch (Precede(GetTop(OPTR), ch))
			{
			case '<':
				Push(OPTR, ch); cin >> ch;
				break;
			case '>':
				char theta;
				Pop(OPTR, theta);
				Postfix.push_back(theta);
				break;
			case '=':
				char x;
				Pop(OPTR, x); cin >> ch;
				break;
			}
		}
	}
	return Postfix;
}
//判定读入的字符ch是否为运算符的函数
bool In(SElemType ch)
{
	if (ch == '+' || ch == '-' || ch == '*' || ch == '/' ||
		ch == '(' || ch == ')' || ch == '=') {
		return true;
	}
	return false;
}
//判定运算符栈的栈顶元素与读入的运算符之间优先关系的函数
SElemType Precede(SElemType optr, SElemType ch)
{
	//规则（1）先乘除，后加减
	if ((optr == '+' || optr == '-') && (ch == '*' || ch == '/')) {
		return '<';
	}
	else if ((optr == '*' || optr == '/') && (ch == '+' || ch == '-')) {
		return '>';
	}
	//规则（2）从左算到右
	if (((optr == '+' || optr == '-') && (ch == '+' || ch == '-')) ||
		((optr == '*' || optr == '/') && (ch == '*' || ch == '/'))) {
		return '>';
	}
	//规则（3）先括号内，后括号外
	//optr不会出现右括号
	if (optr == '+' || optr == '-' || optr == '*' || optr == '/') {
		if (ch == '(') {
			return '<';
		}
		else if (ch == ')' || ch == '=') {
			return '>';
		}
	}
	else if (optr == '(') {
		if (ch == ')') {
			return '=';
		}
		else if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(') {
			return '<';
		}
	}
	//optr中只有'#'的情况
	if (optr == '#' &&
		(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(')) {
		//ch肯定不是'='
		return '<';
	}
}
Status InitStack(SqStack &S)
{
	S.base = new SElemType[MAXSIZE];
	if (!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push(SqStack &S, SElemType e)
{
	if (S.top - S.base == S.stacksize) return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop(SqStack &S, SElemType &e)
{
	if (S.top == S.base) return ERROR;
	e = *--S.top;
	return OK;
}
SElemType GetTop(SqStack S)
{
	if (S.top != S.base) {
		return *(S.top - 1);
	}
}

3.3 执行结果

图3 中缀表达式转化为后缀表达式代码执行结果

4 小题二：基于栈的后缀算术表达式求值

借助一个运算数栈可对后缀表达式进行求值。

4.1 解题思路

将中缀表达式转换为后缀表达式之后，对转换后得到的后缀表达式进行计算的具体步骤如下。

借助一个工作栈OPND ，用以寄存操作数或运算结果。从左到右扫描后缀表达式，读入第一个字符ch 。若ch 不是运算符，则压入OPND 栈，读入下一字符；若ch 是运算符，则从OPND 栈中依次弹出两个数分别到Y 和X ，然后以"X ch Y "的形式计算出结果，将结果压入OPND 栈中。如果后缀表达式未读完，重复执行上面过程，最后OPND栈顶元素即为表达式的求值结果，返回此元素。

4.2 设计代码

cpp 复制代码 
#include <iostream>
#include <iomanip>
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
#define MAXSIZE 100 //顺序栈存储空间的初始分配量
typedef int Status;
typedef char SElemType;
typedef struct
{
	double *base; //栈底指针
	double *top;  //栈顶指针
	int stacksize;//栈可用的最大容量
}SqStack2;
Status InitStack2(SqStack2 &S);
Status Push2(SqStack2 &S, double e);
Status Pop2(SqStack2 &S, double &e);
double GetTop2(SqStack2 S);
//表达式求值相关函数
bool In(SElemType ch);
SElemType Precede(SElemType optr, SElemType ch);
double Operate(double x, SElemType theta, double y);
//计算后缀表达式
double calh(SElemType ch);
int main() {
	SElemType ch;
	while (true) {
		cin >> ch;
		if ('=' == ch) {
			break;
		}
		double res = calh(ch);
		//保留小数点后面2位
		cout << fixed << setprecision(2) << res << endl;
	}
	return 0;
}
double calh(SElemType ch)
{
	SqStack2 OPND;
	InitStack2(OPND);
	while (ch != '=')
	{
		if (!In(ch)) {
			//读入的数没有多位数、小数
			Push2(OPND, double(ch - 48));
		}
		else {
			double x, y;
			Pop2(OPND, y);
			Pop2(OPND, x);
			Push2(OPND, Operate(x, ch, y));
		}
		cin >> ch;
	}
	return GetTop2(OPND);
}
//判定读入的字符ch是否为运算符的函数
bool In(SElemType ch)
{
	if (ch == '+' || ch == '-' || ch == '*' || ch == '/' ||
		ch == '(' || ch == ')' || ch == '=') {
		return true;
	}
	return false;
}
//判定运算符栈的栈顶元素与读入的运算符之间优先关系的函数
SElemType Precede(SElemType optr, SElemType ch)
{
	//规则（1）先乘除，后加减
	if ((optr == '+' || optr == '-') && (ch == '*' || ch == '/')) {
		return '<';
	}
	else if ((optr == '*' || optr == '/') && (ch == '+' || ch == '-')) {
		return '>';
	}
	//规则（2）从左算到右
	if (((optr == '+' || optr == '-') && (ch == '+' || ch == '-')) ||
		((optr == '*' || optr == '/') && (ch == '*' || ch == '/'))) {
		return '>';
	}
	//规则（3）先括号内，后括号外
	//optr不会出现右括号
	if (optr == '+' || optr == '-' || optr == '*' || optr == '/') {
		if (ch == '(') {
			return '<';
		}
		else if (ch == ')' || ch == '=') {
			return '>';
		}
	}
	else if (optr == '(') {
		if (ch == ')') {
			return '=';
		}
		else if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(') {
			return '<';
		}
	}
	//optr中只有'#'的情况
	if (optr == '#' &&
		(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(')) {
		//ch肯定不是'='
		return '<';
	}
}
//进行二元运算的函数
double Operate(double x, SElemType theta, double y)
{
	double z;
	switch (theta)
	{
	case '+':
		z = x + y;
		break;
	case '-':
		z = x - y;
		break;
	case '*':
		z = x * y;
		break;
	case '/':
		z = x / y;
		break;
	default:
		z = 0;
	}
	return z;
}
Status InitStack2(SqStack2 &S)
{
	S.base = new double[MAXSIZE];
	if (!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push2(SqStack2 &S, double e)
{
	if (S.top - S.base == S.stacksize) return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop2(SqStack2 &S, double &e)
{
	if (S.top == S.base) return ERROR;
	e = *--S.top;
	return OK;
}
double GetTop2(SqStack2 S)
{
	if (S.top != S.base) {
		return *(S.top - 1);
	}
}

4.3 执行结果

图4 基于栈的后缀算术表达式求值代码执行结果

5 基于栈的后缀算术表达式求值实验

在基于栈的后缀算术表达式求值实验中，借助栈，可以将中缀算术表达式转换为后缀表达式，并基于后缀表达式求值。

5.1 解题思路

将小题一和小题二合并起来，则可完成基于栈的后缀算术表达式实验。

5.2 设计代码

cpp 复制代码 
#include <iostream>
#include <iomanip>
using namespace std;
//函数结果状态代码
#define OK 1
#define ERROR 0
#define OVERFLOW -2
//Status是函数返回值类型，其值是函数结果状态代码
#define MAXSIZE 100  //顺序栈存储空间的初始分配量
typedef int Status;
typedef struct
{
	char *base; //栈底指针
	char *top;  //栈顶指针
	int stacksize;   //栈可用的最大容量
}SqStack;
Status InitStack(SqStack &S);
Status Push(SqStack &S, char e);
Status Pop(SqStack &S, char &e);
char GetTop(SqStack S);
typedef struct
{
	double *base; //栈底指针
	double *top;  //栈顶指针
	int stacksize;//栈可用的最大容量
}SqStack2;
Status InitStack2(SqStack2 &S);
Status Push2(SqStack2 &S, double e);
Status Pop2(SqStack2 &S, double &e);
double GetTop2(SqStack2 S);
//表达式求值相关函数
bool In(char ch);
char Precede(char optr, char ch);
double Operate(double x, char theta, double y);
//中缀表达式 转 后缀表达式
string ztoh(char ch);
//计算后缀表达式
int calh(string res);
int main() {
	char ch;
	while (true) {
		cin >> ch;
		if ('=' == ch) {
			break;
		}
		string res = ztoh(ch);
		cout << res << endl;
		int r = calh(res);
		cout << r << endl;
	}
	return 0;
}
string ztoh(char ch)
{
	SqStack OPTR;
	InitStack(OPTR);
	Push(OPTR, '#');
	string Postfix = "";
	while (ch != '=' || GetTop(OPTR) != '#')
	{
		if (!In(ch)) {
			Postfix.push_back(ch);
			cin >> ch;
		}
		else {
			switch (Precede(GetTop(OPTR), ch))
			{
			case '<':
				Push(OPTR, ch); cin >> ch;
				break;
			case '>':
				char theta;
				Pop(OPTR, theta);
				Postfix.push_back(theta);
				break;
			case '=':
				char x;
				Pop(OPTR, x); cin >> ch;
				break;
			}
		}
	}
	return Postfix;
}
int calh(string res)
{
	SqStack2 OPND;
	InitStack2(OPND);
	int i = 0;
	char ch = res[i++];
	while (ch != '\0')
	{
		if (!In(ch)) {
			Push2(OPND, double(ch - 48));
		}
		else {
			double x, y;
			Pop2(OPND, y);
			Pop2(OPND, x);
			Push2(OPND, Operate(x, ch, y));
		}
		ch = res[i++];
		//cin >> ch;
	}
	return GetTop2(OPND);
}
//判定读入的字符ch是否为运算符的函数
bool In(char ch)
{
	if (ch == '+' || ch == '-' || ch == '*' || ch == '/' ||
		ch == '(' || ch == ')' || ch == '=') {
		return true;
	}
	return false;
}
//判定运算符栈的栈顶元素与读入的运算符之间优先关系的函数
char Precede(char optr, char ch)
{
	//规则（1）先乘除，后加减
	if ((optr == '+' || optr == '-') && (ch == '*' || ch == '/')) {
		return '<';
	}
	else if ((optr == '*' || optr == '/') && (ch == '+' || ch == '-')) {
		return '>';
	}
	//规则（2）从左算到右
	if (((optr == '+' || optr == '-') && (ch == '+' || ch == '-')) ||
		((optr == '*' || optr == '/') && (ch == '*' || ch == '/'))) {
		return '>';
	}
	//规则（3）先括号内，后括号外
	//optr不会出现右括号
	if (optr == '+' || optr == '-' || optr == '*' || optr == '/') {
		if (ch == '(') {
			return '<';
		}
		else if (ch == ')' || ch == '=') {
			return '>';
		}
	}
	else if (optr == '(') {
		if (ch == ')') {
			return '=';
		}
		else if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(') {
			return '<';
		}
	}
	//optr中只有'#'的情况
	if (optr == '#' &&
		(ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '(')) {
		//ch肯定不是'='
		return '<';
	}
}
//进行二元运算的函数
double Operate(double x, char theta, double y)
{
	double z;
	switch (theta)
	{
	case '+':
		z = x + y;
		break;
	case '-':
		z = x - y;
		break;
	case '*':
		z = x * y;
		break;
	case '/':
		z = x / y;
		break;
	default:
		z = 0;
	}
	return z;
}
Status InitStack(SqStack &S)
{
	S.base = new char[MAXSIZE];
	if (!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push(SqStack &S, char e)
{
	if (S.top - S.base == S.stacksize) return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop(SqStack &S, char &e)
{
	if (S.top == S.base) return ERROR;
	e = *--S.top;
	return OK;
}
char GetTop(SqStack S)
{
	if (S.top != S.base) {
		return *(S.top - 1);
	}
}
Status InitStack2(SqStack2 &S)
{
	S.base = new double[MAXSIZE];
	if (!S.base) exit(OVERFLOW);
	S.top = S.base;
	S.stacksize = MAXSIZE;
	return OK;
}
Status Push2(SqStack2 &S, double e)
{
	if (S.top - S.base == S.stacksize) return ERROR;
	*S.top++ = e;
	return OK;
}
Status Pop2(SqStack2 &S, double &e)
{
	if (S.top == S.base) return ERROR;
	e = *--S.top;
	return OK;
}
double GetTop2(SqStack2 S)
{
	if (S.top != S.base) {
		return *(S.top - 1);
	}
}

5.3 执行结果

图5 基于栈的后缀算术表达式求值实验代码执行结果

6 解题心得

  • 借助一个运算符栈，可以将中缀表达式转换为后缀表达式。
  • 借助一个运算数栈，可以对后缀表达式进行求值。
  • 基于栈的中缀算术表达式求值算法，和基于栈的后缀算术表达式求值算法，是两种重要的表达式求值算法。
相关推荐
九圣残炎7 分钟前
【从零开始的LeetCode-算法】1456. 定长子串中元音的最大数目
java·算法·leetcode
lulu_gh_yu12 分钟前
数据结构之排序补充
c语言·开发语言·数据结构·c++·学习·算法·排序算法
丫头，冲鸭！！！32 分钟前
B树（B-Tree）和B+树（B+ Tree）
笔记·算法
Re.不晚36 分钟前
Java入门15——抽象类
java·开发语言·学习·算法·intellij-idea
ULTRA??1 小时前
C加加中的结构化绑定（解包，折叠展开）
开发语言·c++
凌云行者1 小时前
OpenGL入门005——使用Shader类管理着色器
c++·cmake·opengl
凌云行者1 小时前
OpenGL入门006——着色器在纹理混合中的应用
c++·cmake·opengl
为什么这亚子2 小时前
九、Go语言快速入门之map
运维·开发语言·后端·算法·云原生·golang·云计算
待2 小时前
开源竞争-数据驱动成长-11/05-大专生的思考
人工智能·笔记·学习·算法·机器学习
～yY…s<#>2 小时前
【刷题17】最小栈、栈的压入弹出、逆波兰表达式
c语言·数据结构·c++·算法·leetcode
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解