算式表达式求值

最新推荐文章于 2023-11-02 13:10:35 发布
最新推荐文章于 2023-11-02 13:10:35 发布
阅读量1.6k 收藏 13
点赞数 2
分类专栏： 算式表达式求值 计算器 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dennisming/article/details/106076481
版权

第1章 问题描述与分析
1.1问题描述
一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。假设操作数是正整数，运算符只含加减乘除等四种运算符，界限符有左右括号和表达式起始、结束符“#”，如：#（7+15）（23-28/4）#。引入表达式起始、结束符是为了方便。编程利用“算符优先法”求算术表达式的值。
从键盘读入一个合法的算术表达式，输出正确的结果；显示输入序列和栈的变化过程，操作数类型扩充到实数。
1.2设计分析
在算术表达式中，运算符位于两个操作数中间的表达式称为中缀表达式，例如1+23就是一个中缀表达式,中缀表达式是一种最常用的表达式形式，日常生活中的表达式一般都是用中缀表达式。对中缀表达式的运算，一般遵循先乘除后加减，从左到右计算,先括号内后括号外的规则，因此中缀表达式不仅要依赖运算符优先级，还要处理括号。算术表达式的另一种形式，后缀表达式或逆波兰表达式，就是在算术表达式中运算符在操作数的后面。1+23的后缀表达式为123+。后缀表达式中已经考虑了运算符的优先级，没有括号，只有操作数和运算符，而且越放在前面的运算符越优先执行。同样在算术表达式中，如果运算符在操作数的前面称为前缀表达式如1+23的前缀表达式为+123。后缀表达式是一种十分有用的表达式，它将复杂表达式转化为可以依靠简单的操作，得到计算结果的表达式，所以对中缀表达式的求值过程，是先将中缀表达式转化成后缀表达式，然后对该后缀表达式求值
 
第2章 数据结构与算法设计
2.1数据结构设计
所运用到的存储结构定义：
顺序栈结构
typedef struct
{
ElemType data[MaxSize]; //存放栈中的数据元素
int top; //栈顶指针，即存放栈顶元素在data数组中的下标
}SqStack; //顺序栈类型

2.2算法设计
中缀表达式转后缀表达式的函数算法执行步骤如下，
第一步，从exp中读取字符
第二步，判断字符是否为’\0’。若为’\0’，则将Optr中的所有运算符依次出栈并存放到postexp中，转至第八步。若不为’\0’，则继续执行第三步
第三步，判断读取的字符是否为数字，若为数字则依次将所有的数字存放到postexp中，以#结束，转至第一步。若不为数字字符继续执行下一步
第四步，判断是否为操作符，若是则转至下一步。若不是则执行第六步
第五步，判断Optr是否为空或者栈顶元素为’(’，若不是则比较与栈顶元素的优先级，若栈顶元素优先级高，则将栈顶元素出栈，存入postexp中，将该操作符进栈，反之直接将该操作符存入postexp中。若Optr为空或者栈顶元素为’(’，则将该操作符直接进栈。无论哪一种情况，最终转至第一步。
第六步，判断读取的字符是否为’)’，若是，则将栈中元素依次出栈存入postexp中，直到遇到’(’，将其出栈后便停止出栈，转至第一步，若不是则转至下一步
第七步，该元素为‘(’，直接将其进Optr，转至第一步。
第八步，输出postexp，其结果为后缀表达式

后缀表达式求值的函数算法执行步骤如下，
第一步，从postexp中读取字符
第二步，判断读取的字符是否为’\0’，若是则转至第七步，若不是则执行下一步
第三步，判断读取的字符是否为数字字符，若是则将连续的数字串转换为对应的数值并将其进数值栈Opnd，转至第一步。若不是则转至下一步
第四步，该字符是为操作符，判断该操作符为单目运算符，还是双目运算符。若为单目运算符，转至第五步，若为双目运算符，转至第六步。
第五步，将Opnd栈顶元素弹出，进行运算，将运算结果再次压入Opnd栈顶。返回第一步。
第六步，将Opnd栈顶元素与次栈顶元素弹出进行运算，次栈顶对栈顶进行运算。结果再次压入Opnd栈顶。返回第一步。
第七步，返回栈顶元素，该元素则为最终的结果。
 
附录
(该章将程序的所有代码写入)

#include<iostream>
#include<stdlib.h>
using namespace std;
#include<malloc.h>
#include<math.h>
#define MaxSize 100
typedef char ElemType;
typedef double ElemType1;
typedef struct
{
	ElemType data[MaxSize];		//存放栈中的数据元素
	int top;		//栈顶指针，即存放栈顶元素在data数组中的下标
}SqStack;		//顺序栈类型
void InitStack(SqStack * &s)		//初始化栈的函数
{
	s=(SqStack *)malloc(sizeof(SqStack));		//分配一个顺序栈空间，首地址存放在s中
	s->top=-1;		//栈顶指针置为-1，表示栈空
}
void DestroyStack(SqStack *&s)		//销毁栈的函数
{
	free(s);
}
bool StackEmpty(SqStack *s)		//判断栈是否为空，该函数实际上用于判断s->top==-1是否成立
{
	return(s->top==-1);
}
bool Push(SqStack * &s,ElemType e)		//进栈
{
	if(s->top==MaxSize-1)	//栈满的情况，即栈上溢出
		return false;
	s->top++;		//栈顶指针增1
	s->data[s->top]=e;		//元素e放在栈顶指针处
	return true;
}
bool Pop(SqStack * &s,ElemType &e)		//出栈
{
	if(s->top==-1)		//栈为空的情况，即栈下溢出
		return false;
	e=s->data[s->top];		//取栈顶元素
	s->top--;		//栈顶指针减1
	return true;
}
bool GetTop(SqStack *s,ElemType &e)		//取栈顶元素
{
	if(s->top==-1)		//栈为空的情况，即栈下溢出
		return false;
	e=s->data[s->top];		//取栈顶元素
	return true;
}
typedef struct
{
	ElemType1 data[MaxSize];		//存放栈中的数据元素
	int top;		//栈顶指针，即存放栈顶元素在data数组中的下标
}SqStack1;		//顺序栈类型
void InitStack(SqStack1 * &s)		//初始化栈的函数
{
	s=(SqStack1 *)malloc(sizeof(SqStack1));		//分配一个顺序栈空间，首地址存放在s中
	s->top=-1;		//栈顶指针置为-1，表示栈空
}
void DestroyStack1(SqStack1 *&s)		//销毁栈的函数
{
	free(s);
}
bool StackEmpty(SqStack1 *s)		//判断栈是否为空，该函数实际上用于判断s->top==-1是否成立
{
	return(s->top==-1);
}
bool Push1(SqStack1 * &s,ElemType1 e)		//进栈
{
	if(s->top==MaxSize-1)	//栈满的情况，即栈上溢出
		return false;
	s->top++;		//栈顶指针增1
	s->data[s->top]=e;		//元素e放在栈顶指针处
	return true;
}
bool Pop1(SqStack1 * &s,ElemType1 &e)		//出栈
{
	if(s->top==-1)		//栈为空的情况，即栈下溢出
		return false;
	e=s->data[s->top];		//取栈顶元素
	s->top--;		//栈顶指针减1
	return true;
}
bool GetTop1(SqStack1 *s,ElemType1 &e)		//取栈顶元素
{
	if(s->top==-1)		//栈为空的情况，即栈下溢出
		return false;
	e=s->data[s->top];		//取栈顶元素
	return true;
}
void trans(char *exp,char postexp[])		//将算术表达式exp转化成后缀表达式postexp
{
	char e;
	int i=0;
	SqStack*Optr;		//定义运算符栈指针
	InitStack(Optr);		//初始化运算符栈
	while( *exp!='\0')		//exp表达式未扫描完时循环
	{
		switch(*exp)
		{
		case '('://判定左括号
			exp++;
			if(*exp=='-')
			{
				exp--;
				Push(Optr,'(');		//左括号进栈
				exp+=2;
				postexp[i++]='@';
				break;
			}
			exp--;
			Push(Optr,'(');	
			exp++;		//继续扫描其他字符
			break;
		case ')':		//判定右括号
			Pop(Optr,e);		//出栈元素e
			while(e!='(')		//不为（时循环
			{
				postexp[i++]=e;		//将e存放到postexe中
				Pop(Optr,e);		//出栈元素e
			}
			exp++;		//继续扫描其他字符
			break;
		case '+':		//判定为+或-号
		case '-':
			while(!StackEmpty(Optr))		//栈不空循环
			{
				GetTop(Optr,e);		//取栈顶元素e
				if(e!='(')		//e不是'('
				{
					postexp[i++]=e;		//将e存放到postexp中
					Pop(Optr,e);		//出栈元素e
				}
				else
					break;		//e是'('时退出循环
			}
			Push(Optr,*exp);		//将'+'或'-'进栈
			exp++;		//继续扫描其他字符
			break;
		case '*':		//判定为'*'或'/'号
		case '/':
			while(!StackEmpty(Optr))		//栈不空循环
			{
				GetTop(Optr,e);		//取栈顶元素e
				if(e=='*'||e=='/')		//e是'*'或'/'
				{
					postexp[i++]=e;		//将e存放到postexp中
					Pop(Optr,e);		//出栈元素e
				}
				else
					break;		//e是非'*'或'/'时退出循环
			}
			Push(Optr,*exp);		//将'*'或'/'进栈
			exp++;		//继续扫描其他字符
			break;
		case '^':		//判断为^号
			while(!StackEmpty(Optr))		//栈不空循环
			{
				GetTop(Optr,e);		//取栈顶元素e
				if(e=='^')		//e是'^'
				{
					postexp[i++]=e;		//将e存放到postexp中
					Pop(Optr,e);		//出栈元素e
				}
				else
					break;		//e是非'^'时退出循环
			}
			Push(Optr,*exp);		//将'^'进栈
			exp++;		//继续扫描其他字符
			break;
		case 'l':		//判断为log号
			while(!StackEmpty(Optr))		//栈不空循环
			{
				GetTop(Optr,e);		//取栈顶元素e
				if(e=='l')		//e是'l'
				{
					postexp[i++]=e;		//将e存放到postexp中
					Pop(Optr,e);		//出栈元素e
				}
				else
					break;		//e是非'l'时退出循环
			}
			Push(Optr,*exp);		//将'l'进栈
			exp+=3;		//继续扫描其他字符
			break;
		case'c':	//判断为cos号
			while(!StackEmpty(Optr))		//栈不空循环
			{
				GetTop(Optr,e);		//取栈顶元素e
				if(e=='c')		//e是'l'
				{
					postexp[i++]=e;		//将e存放到postexp中
					Pop(Optr,e);		//出栈元素e
				}
				else
					break;		//e是非'c'时退出循环
			}
			Push(Optr,*exp);		//将'c'进栈
			exp+=3;		//继续扫描其他字符
			break;
		case's':	//判断为sin号
			while(!StackEmpty(Optr))		//栈不空循环
			{
				GetTop(Optr,e);		//取栈顶元素e
				if(e=='s')		//e是's'
				{
					postexp[i++]=e;		//将e存放到postexp中
					Pop(Optr,e);		//出栈元素e
				}
				else
					break;		//e是非's'时退出循环
			}
			Push(Optr,*exp);		//将's'进栈
			exp+=3;		//继续扫描其他字符
			break;
		case't':	//判断为tan号
			while(!StackEmpty(Optr))		//栈不空循环
			{
				GetTop(Optr,e);		//取栈顶元素e
				if(e=='t')		//e是't'
				{
					postexp[i++]=e;		//将e存放到postexp中
					Pop(Optr,e);		//出栈元素e
				}
				else
					break;		//e是非't'时退出循环
			}
			Push(Optr,*exp);		//将't'进栈
			exp+=3;		//继续扫描其他字符
			break;
		default:		//处理数字字符
			while( *exp>='0'&&*exp<='9'||*exp=='.')		//判定为数字和小数点字符
			{
				postexp[i++]= * exp;
				exp++;
			}
			postexp[i++]='#';		//用#标识一个数字串结束
		}
	}
	while(!StackEmpty(Optr))		//此时exp扫描完毕，栈不空时循环
	{
		Pop(Optr,e);		//出栈元素e
		postexp[i++]=e;		//将e放到postexp中
	}
	postexp[i]='\0';		//给postexp表达式添加结束的标志
	DestroyStack(Optr);		//销毁栈
}
double compvalue(char *postexp)		//计算后缀表达式的值
{
	double d,a,b,c,e;
	int n,m=1,w=1;
	SqStack1*Opnd;		//定义操作数栈
	InitStack(Opnd);		//初始化操作数栈
	while( *postexp!='\0')		//postexp字符串未扫描完时循环
	{
		switch( *postexp)
		{
		case'+':		//判定为'+'号
			Pop1(Opnd,a);		//出栈元素a
			Pop1(Opnd,b);		//出栈元素b
			c=b+a;		//计算c
			Push1(Opnd,c);		//将计算结果c进栈
			break;
		case'-':		//判定为'-'号
			Pop1(Opnd,a);		//出栈元素a
			Pop1(Opnd,b);		//出栈元素b
			c=b-a;		//计算c
			Push1(Opnd,c);		//将计算结果c进栈
			break;
		case'*':		//判定为'*'号
			Pop1(Opnd,a);		//出栈元素a
			Pop1(Opnd,b);		//出栈元素b
			c=b*a;		//计算c
			Push1(Opnd,c);		//将计算结果c进栈
			break;
		case'/':		//判定为'/'号
			Pop1(Opnd,a);		//出栈元素a
			Pop1(Opnd,b);		//出栈元素b
			if(a!=0)
			{
				c=b/a;		//计算c
				Push1(Opnd,c);		//将计算结果c进栈
				break;
			}
			else
			{
				printf("\n\t除零错误!\n");
				exit(0);		//异常退出
			}
		case'^':		//判定为'^'号
			Pop1(Opnd,a);		//出栈元素a
			Pop1(Opnd,b);		//出栈元素b
			c=pow(b,a);		//计算c
			Push1(Opnd,c);		//将计算结果c进栈
			break;
		case'l':		//判定为log函数
			Pop1(Opnd,a);		//出栈元素a
			Pop1(Opnd,b);		//出栈元素b
			c=(log(a))/(log(b));		//计算c
			Push1(Opnd,c);		//将计算结果c进栈
			break;	
		case'c':		//判定为cos函数
			Pop1(Opnd,a);		//出栈元素a
			c=cos(a);		//计算c
			Push1(Opnd,c);		//将计算结果c进栈
			break;	
		case's':		//判定为sin函数
			Pop1(Opnd,a);		//出栈元素a
			c=sin(a);		//计算c
			Push1(Opnd,c);		//将计算结果c进栈
			break;	
		case't':		//判定为tan函数
			Pop1(Opnd,a);		//出栈元素a
			c=tan(a);		//计算c
			Push1(Opnd,c);		//将计算结果c进栈
			break;	
		default:
			d=0;		//处理数字字符
			n=0;
			while( *postexp>='0'&& *postexp<='9'||*postexp=='.'||*postexp=='@')		//判定为数字或者小数点
			{
				if(*postexp=='@')
				{m=-1;
				*postexp++;}
				d=10*d+ *postexp-'0';
				postexp++;
				if( *postexp=='.')		//处理小数点之后的数字
				{
					W=-1;
					*postexp++;		//跳过小数点
					n=0;		//无论前面n加了多少次，一旦遇到'.'就从小数点之后开始重新计数
				}
				n++;
			}
			d=d/pow(10,(n-1));		
			d=m*d;
			if(w!=-1)
			{
				d=d*pow(10,n-1);
			}
			m=1;
			w=1;
			Push1(Opnd,d);		//将数值d进栈
			break;
		}
			postexp++;		//处理其他字符
	}
		GetTop1(Opnd,e);		//取栈顶元素
		DestroyStack1(Opnd);		//销毁栈
		return e;		//返回e
}
void behind(char*postexp)    //输出后缀表达式
{
	int t;
	t=strlen(postexp);
	for(int i=0;i<t;i++)
	{
		if(*(postexp+i)=='s') {cout<<"sin";continue;}
		if(*(postexp+i)=='l') {cout<<"log";continue;}
		if(*(postexp+i)=='c') {cout<<"cos";continue;}
		if(*(postexp+i)=='t') {cout<<"tan";continue;}
		if(*(postexp+i)=='@') {cout<<"-";continue;}
		cout<<*(postexp+i);
	}
	cout<<endl;
}
int main()
{
	while(1)
	{
	int q;
	cout<<"**- 请输入算术表达式 -**"<<endl;
	char exp[MaxSize];
	char postexp[MaxSize];
	cin>>exp;		//输入算术表达式
	trans(exp,postexp);
	cout<<"中缀表达式:"<<exp<<endl;
	cout<<"后缀表达式";
	behind(postexp);
	cout<<"表达式的值"<<compvalue(postexp)<<endl;
	cout<<"enter '1' clear  the  screen  "<<endl;
	cin>>q;
	switch(q)
	{
	case 1:system("cls");
	default :break;
	}
	}
	return 1;
} 
Dennisming
关注
  • 2
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
7-1 表达式求值
weixin_45807332的博客
08-03 3121
编写程序，从键盘输入一个合法的表达式，对该表达式进行求值并输出，为降低题目难度，特做如下要求： 运算数均为整型数（即不带小数点） 运算符只支持加减乘除四种（+、-、、/）以及小括号（()） 计算规则为实型数运算规则，例如1/2=0.5 输出计算结果保留两位小数（四舍五入） 表达式中不允许出现如下情况 空字符串 错误的运算符 错误的运算数 括号不匹配 空括号 连续的运算符，例如–5 运算符为正数时，其符号+必须省略，例如+2+4定义为非法，而负数时为合法，例如-2+4 程序要能处理表达式中间出现的空格（输入表
用C语言写一个 从键盘上输入一个四则运算的式子并输出计算结果
weixin_35752645的博客
12-25 1751
首先，可以使用 scanf 函数从键盘输入一个字符串，然后使用栈来处理这个字符串并计算表达式的结果。 代码示例如下： ``` #include <stdio.h> #include <stdlib.h> #include <ctype.h> #define MAX_STACK_SIZE 100 // 定义栈结构体 typedef struct { doubl...
PTA---java表达式求值
qq_45028587的博客
06-07 1812
编写程序，从键盘输入一个合法的表达式，对该表达式进行求值并输出，为降低题目难度，特做如下要求： 出题人：段喜龙 运算数均为整型数（即不带小数点） 运算符只支持加减乘除四种（+、-、*、/）以及小括号（()） 计算规则为实型数运算规则，例如1/2=0.5 输出计算结果保留两位小数（四舍五入） 表达式中不允许出现如下情况 空字符串 错误的运算符 错误的运算数 括号不匹配 空括号 连续的运算符，例如–5 运算符为正数时，其符号+必须省略，例如+2+4定义为非法，而负数时为合法，例如-2+4 程序要能处理表达式中间
表达式求值
qq_44918132的博客
07-10 847
表达式求值 1、掌握栈的特性，能利用栈的特性进行实际应用。 2、掌握“运算符优先法”，并能利用该算法对表达式求值。 1、求一个表达式的值：输入一个包含“+”、“-”、“*”、“/”、正整数和圆括号的合法表达式，计算该表达方式的运算结果。 2、有能力的同学可以考虑操作数为多位浮点数的情况。 3、所写源代码编程风格良好，有详细注释。 4、程序运行界面良好。  #include<io...
PTA7-1 表达式求值C++
weixin_74454372的博客
11-02 496
编写程序，从键盘输入一个合法的表达式，对该表达式进行求值并输出
算术表达式求值（南航2022数据结构课设第二题）
青耕_的博客
02-02 952
一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。假设操作数是正实数，运算符只含加减乘除等四种运算符，界限符有左右括号和表达式起始、结束符“#”，如：#6+15*（21-8/4）#。引入表达式起始、结束符是为了方便。编程利用“运算符优先法”求算术表达式的值。
改进后的算式表达式求值 支持整型和实型
04-06
本文将深入探讨“改进后的算式表达式求值 支持整型和实型”的主题，这对于理解和编写计算器应用、科学计算软件等具有重要意义。 首先，我们来了解表达式求值的基本概念。在计算机科学中，表达式是含有操作符和操作...
zhengxing.rar_表达式求值
09-24
在编程领域，表达式求值（Expression Evaluation）是一项基本任务，尤其在解释器或编译器设计中至关重要。"zhengxing.rar_表达式求值"这个项目显然关注于实现一个简单的整型表达式求值器，它能够处理包含基本算术...
VC++编写的表达式求值
07-20
在编程领域，表达式求值是一项基础且重要的任务，它涉及到如何解析和计算数学或逻辑表达式的值。在这个“VC++编写的表达式求值”项目中，我们可以探索使用Microsoft的Visual C++（简称VC++）编译器来实现这个功能。...
数据结构中的算术表达式求值
12-07
根据给定的信息，本文将详细解释如何通过C语言利用栈来实现算术表达式的求值。这种方法的关键在于使用两个栈：一个用于存储数字（数值栈），另一个用于存储运算符（运算符栈）。此外，还需要考虑优先级问题以及括号...
数据结构VC++表达式求值
07-07
本项目"数据结构VC++表达式求值"聚焦于如何利用MFC（Microsoft Foundation Classes）库在VC++环境中实现一个能够解析并计算表达式的程序。MFC是一个C++类库，它提供了许多Windows应用程序开发所需的基本功能，如窗口...
C语言编写的算术表达式求值程序
12-10
（1） 从键盘读入一个合法的算术表达式，输出正确的结果。（2） 显示输入序列和栈的变化过程。（3） 考虑算法的健壮性，当表达式错误时，要给出错误原因的提示
数字表达式的计算 C语言
qq_66040869的博客
05-18 3651
功能要求： 1.从键盘输入一段表达式(字符串)，其中含有整数、加、减、乘、除。 2.计算表达式的值。 3.事先约定表达式无括号、无浮点数、无负数、无错误。 exp存放输入的表达式 opera存放表达式中的运算符 num存放表达式中的数字。 注意：该程序应兼容输入表达式（字符串）中有空格的情况，所以选择gets()而不是scanf()来获取字符串。（字符输入函数getchar 字符输出函数putchar 字符串输入函数gets 字符串输出函数puts，gets只以回车作为分隔符...
数据结构 C++实现 算术表达式求值
qq_54388490的博客
03-25 1万+
文章目录一、实验目的二、实验要求三、代码内容1、创建链栈并初始化2、入栈出栈取栈顶元素3、判断是否是运算符4、判断运算符优先级5、运算函数6、总代码四、运算结果五、总结 一、实验目的 1、了解栈的特性,以及它在实际问题中的应用。 2、掌握栈的实现方法以及它的基本操作，学会运用栈来解决问题。 二、实验要求 表达式求值是数学中的一个基本问题，也是程序设计中的一个经典问题。我们所涉及的表达式中包含数字（一位正整数）和运算符号，本课程设计中处理的运算符号包括‘+’、‘-’、‘’、‘/’、‘（’和‘）’。要求按照我们
Java算法题 给一个字符串表达式，实现一个基本计算器，返回计算结果
qq_42490860的博客
04-06 2051
若当前字符为数值类型，判断下一个字符是否也是数值型，如果是说明这个数是不完整的需要与下一个数字拼接得到一个完整的整数（String转Integer），直到下一个字符为非数值类型，把它压入操作数栈中。运算规则：栈是后进先出，参与加减乘除运算时，第一个从 stack_nums 栈顶弹出的数应在运算符后面，第二个 stack_nums 从栈顶弹出的数应在运算符前面。若当前字符为'+', '-', '*', '/', '(' 时，压入运算符栈 stack_symbol，第二种是，需要优先进行运算的式子。
算术表达式求值(栈结构及其应用) - C语言
热门推荐
友人帐_的博客
10-24 1万+
表达式求值是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。一个算术表达式是由操作数（operand）、运算符（operator）和界限符（delimiter）组成的。假设操作数是正整数，运算符只含加减乘除等四种二元运算符，界限符有左右括号和表达式起始、如：（7+15）*（23-28/4）。引入表达式起始、结束符是为了方便。设计一个程序，演示算术表达式求值的过程。
LeetCode习题：计算器
huazi_iOS的博客
03-25 303
题目描述：给定一个包含正整数、加(+)、减(-)、乘(*)、除(/)的算数表达式(括号除外)，计算其结果。表达式仅包含非负整数，+，- ，*，/ 四种运算符和空格  。 整数除法仅保留整数部分。 示例： 例1： 输入: "3+2*2" 输出: 7 例2： 输入: " 3/2 " 输出: 1 例3： 输入: " 3+5 / 2 " 输出: 5 解题思路：双栈计算。创建两个栈结构，分别用于保存数字和运算符，遍历字符串时，遇到运算符，将当前运算符与运算符栈的栈顶进行优先级比较，如果栈顶运
算法——模拟四则运算
Think Different.
11-19 657
给定一个包含正整数、加(+)、减(-)、乘( * )、除(/)的算数表达式(括号除外)，计算其结果。 表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。 leetcode 解题思路：模拟CPU进行运算的方式，利用栈的思想。遍历字符串，如果遇到符号，则读取下一个数字，然后判断符号。 如果是乘除，那么直接拿这个数字和栈顶元素运算。 如果是减号，则将当前元素变为负数。 如果是加号，则不操作。 运算完成符号之后，再将处理过的数值放到栈顶。 最后完成遍历，将栈中的元素都.
数据结构：c++算术表达式求值
鸭绒的博客
12-18 8306
算术表达式求值 [问题描述]　　一个算术表达式是由操作数(operand)、运算符(operator)和界限符(delimiter)组成的。假设操作数是正实数，运算符只含加减乘除等四种运算符，界限符有左右括号和表达式起始、结束符“#”，如：#（7+15）*（23-28/4）#。引入表达式起始、结束符是为了方便。编程利用“运算符优先法”求算术表达式的值。 解题思路： 1.首先建立两个栈用来分别存储操...
算术表达式求值c++
最新发布
11-07
算术表达式求值是指将一个数学表达式转化为计算机可以理解的形式，并计算出表达式的结果。C++是一种常用的编程语言，可以用来编写算术表达式求值程序。该程序可以支持括号运算、小数运算、错误点报错（非法字符、括号不完整、缺运算数、算式不完整等）、中间过程显示（输入串、运算数栈、操作符栈）等功能。在C++中，可以使用栈来实现算术表达式求值。具体实现方法可以参考引用中提供的C++代码。另外，引用中也提供了一个基本的表达式求值问题的描述和解决方法，可以作为参考。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值