C++实验表达式求值

最新推荐文章于 2024-07-20 11:22:21 发布
最新推荐文章于 2024-07-20 11:22:21 发布
阅读量178 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 中缀表达式 表达式求值 栈 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45906196/article/details/120800508
版权

主要功能：

  • 中缀表达式转换为后缀表达式
  • 中缀表达式的计算
  • 后缀表达式的计算

源码：

# include <iostream>
# include <stdlib.h>
using namespace std;
# define MAXSIZE 100
void menu(){
   cout<<" ------------------------------------------------------"<<endl;
		cout<<"表达式求值"<<endl;
		cout<<"1. 中缀表达式到后缀表达式的转换"<<endl;
		cout<<"2. 后缀表达式的计算"<<endl;
		cout<<"3. 中缀表达式的计算"<<endl;
		cout<<"4. 退出"<<endl;
cout<<"-------------------------------------------------------"<<endl;

}
//---------------------------------------------------
typedef struct  //操作数栈的结构体（整形）
{
    int *base;
    int *top;
    int stacksize;
}Stack;
int InitStack(Stack &s)//操作数栈初始化
{
    s.base = new int[MAXSIZE];
    if(!s.base)
        return 0;
    s.top = s.base;
    s.stacksize = MAXSIZE;
    return 1;
}
void Push(Stack &s,int e)//操作数栈入栈
{
    if(s.base-s.top==s.stacksize)
        cout<<"栈满"<<endl;
    else{
        *s.top = e;
        s.top++;
    }
}
void Pop(Stack &s)//操作数栈出栈
{
    if(s.top==s.base)
        cout<<"栈空"<<endl;
    s.top--;
}
int GetTop(Stack &s)//取栈顶元素
{
    if(s.top!=s.base)
        return *(s.top-1);
        else
            return 0;
}
//------------------------------------------------

typedef struct//运算符队列结构体
{
    char *base;
    int front;
    int rear;
}SqQueue;
int InitQueue(SqQueue &s)//初始化队列
{
    s.base = new char[100];
    if(!s.base)
        return 0;
    s.front = s.rear = 0;
    return 1;
}
int QueueLength(SqQueue &s)//求队列长度
{
    return (s.rear+MAXSIZE-s.front)%MAXSIZE;
}
void EnQueue(SqQueue &s,char e)//入队操作
{
    if((s.rear+1)%MAXSIZE==s.front)
        cout<<"队列已满无法入队"<<endl;
    else{
        s.base[s.rear] = e;
        s.rear = (s.rear+1)%MAXSIZE;
    }
}
void DeQueue(SqQueue &s,char e)//出队操作
{
    if(s.rear==s.front)
    {
        cout<<"队列为空无法出队"<<endl;
    }
    else{
        e = s.base[s.front];
        s.front = (s.front+1)%MAXSIZE;
    }
}
char GetHead(SqQueue &s)//取队头元素
{
    if(s.rear!=s.front)
    {
        return s.base[s.front];
    }
}
//----------------------------------------------------------------
typedef struct  //定义运算符栈的结构体
{
    char *base;
    char *top;
    int stacksize;
}SqStack;

int InitStack(SqStack &s)//运算符栈初始化
{
    s.base = new char[MAXSIZE];
    if(!s.base)
        return 0;
    s.top = s.base;
    s.stacksize = MAXSIZE;
    return 1;
}
void Push(SqStack &s,char e)//运算符顺序栈入栈
{
    if(s.base-s.top==s.stacksize)
        cout<<"栈满"<<endl;
    else{
        *s.top = e;
        s.top++;
    }
}
void Pop(SqStack &s,char e)//运算符顺序栈出栈
{
    if(s.top==s.base)
        cout<<"栈空"<<endl;
    s.top--;
    e = *s.top;
}
char GetTop(SqStack &s)//取栈顶元素
{
    if(s.top!=s.base)
        return *(s.top-1);
        else
            return 0;
}
int YouXianJi(char ch){//判断符号的优先级
	int p;
    switch(ch){
	   case '#': p = 0; break;
 	   case '(': p = 1; break;
	   case '+': p = 2; break;
	   case '-': p = 2; break;
	   case '*': p = 3; break;
	   case '/': p = 3; break;
	}
	return p;
}
//--------------------------------------------------------------------------------------
void ZhongZhuanHou(SqStack &S,SqQueue &Q){ //将中缀表达式转换成后缀表达式
    char a[100];//用于存储输入的表达式
	int i,e;
	char ch;
	char *p;
	Push(S,'#');//将#压入方便操作
	cout<<"请输入中缀表达式(以@结束)"<<endl;
	cin>>a;
    for(i=0;a[i]!='@';i++){
		if(a[i]>='0'&&a[i]<='9'){//如果是数字直接入队
		     EnQueue(Q,a[i]);
		}
	     	else{//如果是符号进行以下判断
				if(a[i]=='('){//如果是（直接入栈
				     Push(S,a[i]);
				}
				else if(a[i]==')'){//如果是右括号将栈中压在左括号上的元素依次入队并弹出栈
				do{
                  	EnQueue(Q,GetTop(S));
				    Pop(S,ch);
				}while(GetTop(S)!='(');
				Pop(S,ch);//将左括号弹出
				}
				else{
			while(YouXianJi(a[i])<=YouXianJi(GetTop(S))){//如果读到的运算符优先级比栈顶元素的小，则将栈顶元素入队后弹出栈
			   	EnQueue(Q,GetTop(S));
			     Pop(S,ch);
			}
			if(YouXianJi(a[i])>YouXianJi(GetTop(S))){//如果相反，则直接压入运算符栈
			     Push(S,a[i]);
			}
				}
		}
	}
    while(GetTop(S)!='#'){//读到#说明到栈底了，将栈中的元素依次入队弹出
	    EnQueue(Q,GetTop(S));
		Pop(S,ch);
	}

       Pop(S,ch);//将#也弹出
}
//-----------------------------------------------------------------------------------------------------------------------
int ZhuanHuan(char ch){  //将字符型转换成整形
    switch(ch){
	case '1':return 1;break;
    case '2':return 2;break;
	case '3':return 3;break;
	case '4':return 4;break;
	case '5':return 5;break;
	case '6':return 6;break;
	case '7':return 7;break;
	case '8':return 8;break;
	case '9':return 9;break;
	case '0':return 0;break;
	}
}
int JS(int m,int n,char ch){ //计算表达式
	if(ch=='+'){
	     return m+n;
	}
	if(ch=='-'){
	     return m-n;
	}
	if(ch=='*'){
	     return m*n;
	}
	if(ch=='/'){
	     return m/n;
	}
}
int HouJiSuan(Stack &S,SqQueue &Q){ //后缀表达式计算
	int m,n,p,k,l;
	char ch;
	while(Q.front!=Q.rear){//如果队列不空依次读取队列中的元素
	     ch = GetHead(Q);
		if(ch>='0'&&ch<='9'){//如果队列中的是数字则将字符栈中字符转换成数字在压入操作数栈中
			k = ZhuanHuan(ch);
		    Push(S,k);
		}
		else{//如果读到字符，则在栈中弹出两个数赋值给m和n，计算将结果存入操作数栈中
		    m = GetTop(S);
			Pop(S);
			n = GetTop(S);
			Pop(S);
			p = JS(n,m,ch);
			Push(S,p);
		}
		DeQueue(Q,ch);//出队
	}
	return p;

}
//---------------------------------------------------------------------------------------------------------
typedef struct  //定义操作数栈的结构体
{
    float *base;//可以存入浮点型数据
    float *top;
    int stacksize;
}ShuStack;
int InitShuStack(ShuStack &s)//操作数栈初始化
{
    s.base = new float[MAXSIZE];
    if(!s.base)
        return 0;
    s.top = s.base;
    s.stacksize = MAXSIZE;
    return 1;
}
void Push(ShuStack &s,float e)//操作数入栈
{
    if(s.base-s.top==s.stacksize)
        cout<<"栈满"<<endl;
    else{
        *s.top = e;
        s.top++;
    }
}
void Pop(ShuStack &s)//操作数出栈
{
    if(s.top==s.base)
        cout<<"栈空"<<endl;
    s.top--;
}
float GetTop(ShuStack &s)//操作数栈取栈顶元素
{
    if(s.top!=s.base)
        return *(s.top-1);
        else
            return 0;
}
typedef struct  //定义运算符栈的结构体
{
    char *base;
    char *top;
    int stacksize;
}FuStack;
int InitFuStack(FuStack &s)//运算符栈初始化
{
    s.base = new char[MAXSIZE];
    if(!s.base)
        return 0;
    s.top = s.base;
    s.stacksize = MAXSIZE;
    return 1;
}
void FuPush(FuStack &s,char e)//运算符顺序栈入栈
{
    if(s.base-s.top==s.stacksize)
        cout<<"栈满"<<endl;
    else{
        *s.top = e;
        s.top++;
    }
}
void FuPop(FuStack &s)//运算符顺序栈出栈
{
    if(s.top==s.base)
        cout<<"栈空"<<endl;
    s.top--;
}
int FuGetTop(FuStack &s)//运算符栈取栈顶元素
{
    if(s.top!=s.base)
        return *(s.top-1);
        else
            return 0;
}
//判断是否为数字或小数点
int IsShuDian(char x){
    if((x>='0'&&x<='9')||x=='.')
        return 1;
    return 0;
}
char Precede(char c1,char c2){//    比较两个操作符的优先级
  if(c1=='+')
  {
    if(c2=='+') return  '>';
    else if(c2=='-') return  '>';
    else if(c2=='*') return  '<';
    else if(c2=='/') return  '<';
    else if(c2=='(') return  '<';
    else if(c2==')') return  '>';
    else return  '>';
   }
  else if(c1=='-')
  {
    if(c2=='+') return  '>';
    else if(c2=='-') return  '>';
    else if(c2=='*') return  '<';
    else if(c2=='/') return  '<';
    else if(c2=='(') return  '<';
    else if(c2==')') return  '>';
    else return  '>';
   }
   else if(c1=='*')
  {
    if(c2=='+') return  '>';
    else if(c2=='-') return  '>';
    else if(c2=='*') return  '>';
    else if(c2=='/') return  '>';
    else if(c2=='(') return  '<';
    else if(c2==')') return  '>';
    else return  '>';
   }
   else if(c1=='/')
  {
    if(c2=='+') return  '>';
    else if(c2=='-') return  '>';
    else if(c2=='*') return  '>';
    else if(c2=='/') return  '>';
    else if(c2=='(') return  '<';
    else if(c2==')') return  '>';
    else return  '>';
   }
   else if(c1=='(')
  {
    if(c2=='+') return  '<';
    else if(c2=='-') return  '<';
    else if(c2=='*') return  '<';
    else if(c2=='/') return  '<';
    else if(c2=='(') return  '<';
    else return  '=';

   }
   else if(c1==')')
  {
    if(c2=='+') return  '>';
    else if(c2=='-') return  '>';
    else if(c2=='*') return  '>';
    else if(c2=='/') return  '>';

    else if(c2==')') return  '>';
    else return  '>';
   }
   else
  {
    if(c2=='+') return  '<';
    else if(c2=='-') return  '<';
    else if(c2=='*') return  '<';
    else if(c2=='/') return  '<';
    else if(c2=='(') return  '<';

    else return  '=';
   }
}
float JS1(float m,float n,char ch){ //计算表达式
	if(ch=='+'){
	     return m+n;
	}
	if(ch=='-'){
	     return m-n;
	}
	if(ch=='*'){
	     return m*n;
	}
	if(ch=='/'){
	     return m/n;
	}
}
void ZhongJiSuan(ShuStack &S,FuStack &S1){
      char chuan[MAXSIZE];//用于输入表达式
	  char LinShi[MAXSIZE];
	  int i=0;
	  float f,e1,e2,e3;
	  int j=0;
	  char ch,ch1;
	  cout<<"请输入中缀表达式"<<endl;
	  cin>>chuan;
	  FuPush(S1,'#');//将#压入运算符栈中
	  while(chuan[i]!='#'||FuGetTop(S1)!='#'){//如果表达式没读完或运算符栈还有元素执行循环体
		  if((chuan[i]>='0'&&chuan[i]<='9')||chuan[i]=='.'||((chuan[i]=='-')&&(chuan[i-1]<'0'||chuan[i-1]>'9')&&(chuan[i-1]!=')')))//如果是数字
		  {
			  while((chuan[i]>='0'&&chuan[i]<='9')||chuan[i]=='.'||((chuan[i]=='-')&&(chuan[i-1]<'0'||chuan[i-1]>'9')&&(chuan[i-1]!=')')))
			  {
				LinShi[j]=chuan[i];//将数存到临时数组里
				i++;
				j++;
			  }
			  LinShi[j]='\0';
			  f = atof(LinShi);//调用库函数将临时数组中的数据转换成浮点数
			  Push(S,f);//将数据压入运算数栈
			  j = 0;//将临时存放数据的数组清空用于第二次转换
		  }
		  else{
				  if(Precede(FuGetTop(S1),chuan[i])=='<'){//如果读到的符号比符号栈栈顶元素优先级高则将其压入符号栈
					   FuPush(S1,chuan[i]);
					   i++;
				  }
				 else if(Precede(FuGetTop(S1),chuan[i])=='>'){//如果读到的符号比符号栈栈顶元素优先级低则弹出操作数栈中的两个数计算完后压入运算数栈
					  ch1 = FuGetTop(S1);
					  FuPop(S1);
					  e1 = GetTop(S);
					 Pop(S);
					 e2 = GetTop(S);
					  Pop(S);
					  e3 = JS1(e2,e1,ch1);
					  Push(S,e3);
				  }
				  else/*(Precede(FuGetTop(S1),chuan[i])=='=')*/{//如果优先级相等则弹出运算符
					  FuPop(S1);
					  i++;
				  }

		  }
	  }
	 cout<<"运算结果是"<<GetTop(S)<<endl;
}
main(){
	int n;
	int i;
      SqStack S;
	  SqQueue Q;
	  Stack S1;
	  ShuStack SS;//
	  FuStack S2;//
	  InitShuStack(SS);
      InitFuStack(S2);
	  InitStack(S);
	  InitQueue(Q);
      InitStack(S1);
	  while(1){
	      menu();
		  cout<<"请输入所选功能"<<endl;
		  cin>>n;
		  if(n==1){
		      ZhongZhuanHou(S,Q);
			  for(i=Q.front;i!=Q.rear;i++){
			     cout<<Q.base[i]<<" ";
			  }
			  cout<<endl;
		  }
		  if(n==2){
		      cout<<HouJiSuan(S1,Q)<<endl;
		  }
		  if(n==3){
		      ZhongJiSuan(SS,S2);
		  }
		  if(n==4)
			  break;
	  }
}
/*main(){
   	int i;
	menu();
	 SqStack S;
	 SqQueue Q;
	 Stack S1;
	 char ch;
     InitStack(S);
	 InitQueue(Q);
     InitStack(S1);
	 ZhongZhuanHou(S,Q);
	cout<<HouJiSuan(S1,Q)<<endl;
}*/

//1+2*(3-1+2)-3@
//12.3+-11.3-2#

二琳爱吃肉
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++实现表达式求值 文件
04-14
C++实现表达式求值 本实验要求设计一个算术表达式求值的程序，该程序必须可以接受包含（，），+，-，*,/,%,和^(求幂运算符，a^b=ab )的中缀表达式，并求出结果。如果表达式正确，则输出表达式的结果；如果表达式非法...
表达式求值（改进）（C++）.zip
09-13
用C++实现的表达式求值，主要功能为输入表达式的处理（去空格，处理特殊正负号，表达式逻辑合法性判断）、中缀转后缀（前缀为后缀的逆序）、后缀表达式求值。已经考虑到了我所能想到的所有的不合法表达式的判断处理...
C++语言程序设计实验报告——实验五
萌新程序猿的博客
01-01 2338
实验内容: 1.有两个矩阵A和B，均为3行3列。重载运算符“+”和“*”，使之分别能用于矩阵相加和相乘。C = A+B， C = A*B。 2.定义抽象类Geometry，含有计算几何图形周长的纯虚函数double Circumfer（）；含有计算面积的纯虚函数double Area（）;在此基础上公有的派生出矩形类Rectangle，和圆类Circle,并且分别给出计算周长函数Circumf()和计算面积函数Area()的定义。最后通过函数fun()分别输出面积和周长。可以在主函数中使用以下语句来测试类。
表达式求值（c++实现）
fx1ts的专栏
10-29 1673
今天写了一个表达式求值的程序。基本功能为:输入一个表达式比如23*34-21+(56*(45-1)) 然后程序求出结果。而且按照四则运算的优先级，同时支持括号。下面是程序运行的画面： 程序的难点在于把一个字符串分解为操作数和操作符并能正确处理各个操作符的优先级，特别是有括号的情况。本程序主要采用了传统的方法创建了操作数栈和操作符栈。关于操作符优先级的处理采用了一个关联数组来处理。还有很多
中缀表达式的求值
weixin_58227246的博客
10-19 1334
中缀表达式求值，算法思路的原理图示 (代码写的不简洁，但运行结果没问题，思路比较好看出来，仅仅为不会的小白参考和自己记录下来) 注意点 1.遇到操作符出栈时，需要弹出两个操作数，先弹出的操作数y为减数或除数，后弹出的x为被减数或被除数。 2.输入中缀表达式是字符串，字符串中的数字需要转化成整形数据，下面代码的getNum()函数实现。 3.操作符栈和操作数栈存放两种不同类型的变量。 #include<stdio.h> #include<stdlib.h> #define MAXN 1
【栈与队列】给定一个中缀表达式，请编写程序计算该表达式的值。（java）
m0_67463447的博客
03-17 2643
给定一个中缀表达式，请编写程序计算该表达式的值。表达式包含+、-、*、\、(、)，所有运算均为二元运算，操作数均为正整数，但可能不止一位，不超过5位。 运算结果为整数。 除法运算结果若为小数则进行截尾取整。若除法运算中除数为0，则输出ILLEGAL。 输入格式: 输入为一个字符串，表示中缀表达式。 输出格式: 输出为一个整数，为表达式的值；或者为一个字符串ILLEGAL。 输入样例: 5+(10*2)-6 输出样例: 19 输入样例: 8*(999+1) 输出样例: 8
数据结构 C++实现 算术表达式求值
热门推荐
qq_54388490的博客
03-25 1万+
文章目录一、实验目的二、实验要求三、代码内容1、创建链栈并初始化2、入栈出栈取栈顶元素3、判断是否是运算符4、判断运算符优先级5、运算函数6、总代码四、运算结果五、总结 一、实验目的 1、了解栈的特性,以及它在实际问题中的应用。 2、掌握栈的实现方法以及它的基本操作，学会运用栈来解决问题。 二、实验要求 表达式求值是数学中的一个基本问题，也是程序设计中的一个经典问题。我们所涉及的表达式中包含数字（一位正整数）和运算符号，本课程设计中处理的运算符号包括‘+’、‘-’、‘’、‘/’、‘（’和‘）’。要求按照我们
后缀表达式求值-C++实现
TLJava^v^的博客
04-20 7287
一、思路 给出一个后缀表达式（以字符串数组的形式，每一项要么是一个操作数字符串，要么是一个运算符），计算过程中要将操作数从string形式转换为int形式，在计算表达式运算结果时，需要设置一个栈 num 保存操作数，计算步骤如下： 1）若当前项是操作数，则将该操作数压入num栈中； 2）若当前项是运算符，则从操作数栈中出栈两个操作数（栈顶的数作为第二个操作数，次栈顶的数作为第一个操作数），计算两个操作数进行运算的结果，然后将结果压入操作数栈num中。
C++算术表达式求值
程序设计
10-10 452
设计一个程序，用算符优先法对算术表达式求值。
C/C++表达式求值实验报告
11-19
本文是关于C/C++编程中实现表达式求值的一个实验报告，主要涉及算符优先法。实验目的是设计一个程序，能够处理包含加、减、乘、除和括号的四则混合运算表达式，通过计算得出正确结果。 一、需求分析 实验要求设计一...
C++ 栈和队列 中缀表达式求值
04-24
采用栈和队列数据结构及C++程序设计语言实现中缀表达式求值#数据结构实验#栈和队列应用#C++程序设计语言
表达式求值C++代码（含实验报告）
09-03
在本项目中，我们主要关注的是使用C++编程语言实现表达式求值的功能。这是一个典型的数据结构与算法问题，尤其适用于计算机科学与信息技术专业的学生进行实践学习。C++是一种强大的编程语言，它提供了丰富的特性来...
中缀表达式求值
weixin_30807779的博客
10-29 2556
描述 人们熟悉的四则运算表达式称为中缀表达式，例如(23+34*45/(5+6+7))。在程序设计语言中，可以利用堆栈的方法把中缀表达式转换成保值的后缀表达式（又称逆波兰表示法），并最终变为计算机可以直接执行的指令，得到表达式的值。给定一个中缀表达式，编写程序，利用堆栈的方法，计算表达式的值。 输入 第一行为测试数据的组数N接下来的N行，每行是一个中缀表达式。表达式中只含数字、四则运算符和圆...
pta-表达式求值
Tom里的同学的博客
11-12 5141
7-2 表达式求值 (10 分) 给定一个中缀表达式，请编写程序计算该表达式的值。表达式包含+、-、*、\、(、)，所有运算均为二元运算，操作数均为正整数，但可能不止一位，不超过5位。运算结果为整数，值域为[−2 ^31,2 ^31)。除法运算结果若为小数则进行截尾取整。若除法运算中除数为0，则输出ILLEGAL。 输入格式: 输入为一个字符串，表示中缀表达式。 输出格式: 输出为一个整数，为表达式的值；或者为一个字符串ILLEGAL。 输入样例1: 5+(10*2)-6 输出样例1: 19 输入样例2:
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 229
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1011
可以参考以下视频。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 205
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 844
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
中缀转后缀表达式及求值C++程序设计
"该资源是一个关于使用C++编程将中缀表达式转换为后缀表达式的实验报告。实验目标是熟悉线性表和栈的操作，通过栈实现中缀到后缀的转换，并利用后缀表达式计算数值。实验要求包括使用栈进行操作，接收用户输入的中缀...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

二琳爱吃肉

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

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

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

打赏作者

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

抵扣说明：

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

余额充值