算术表达式求值 急求

发布网友 发布时间：2023-03-11 18:32

我来回答

共2个回答

热心网友 时间：2023-05-11 19:18

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define error 0
#define ok 1
#define overflow -1
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OPSETSIZE 7
char OPSET[OPSETSIZE]={'+','-','*','/','(',')','#'};
unsigned char Prior[7][7] = { // 算符间的优先关系
'>','>','<','<','<','>','>',
'>','>','<','<','<','>','>',
'>','>','>','>','<','>','>',
'>','>','>','>','<','>','>',
'<','<','<','<','<','=',' ',
'>','>','>','>',' ','>','>',
'<','<','<','<','<',' ','='
};
typedef int Status;

template <typename T>
struct SqStack
{
T *top;
T *base;
int stacksize;

};//顺序栈结构模板

template <typename T1,typename T2>
Status InitStack(T1 &S)
{
S.base=(T2 *)malloc(STACK_INIT_SIZE*sizeof(T2));
if(!S.base) exit (overflow);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return ok;
}//初始化栈函数模板

template <typename T1,typename T2>
Status Push(T1 &S,T2 e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(T2 *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(T2));
if(!S.base) exit (overflow);
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return ok;
}//入栈函数模板

template <typename T1,typename T2>
Status Pop(T1 &S,T2 &e)
{
if(S.top==S.base) return error;
e=*--S.top;
return ok;
}//出栈函数模板

template <typename T1,typename T2>
T2 GetTop(T1 S)
{
if(S.top==S.base)
return error;
else
return *(S.top-1);

}//获取栈顶元素模板

Status In(char Test,char* TestOp) {
bool Find=false;
for (int i=0; i< OPSETSIZE; i++) {
if (Test == TestOp[i]) Find= true;
}
return Find;
}//判断是否为运算符

float Operate(float a,unsigned char theta, float b) {
switch(theta) {
case '+': return a+b;
case '-': return a-b;
case '*': return a*b;
case '/': return a/b;
default : return 0;
}
}//运算

int ReturnOpOrd(char op,char* TestOp) {
int i;
for(i=0; i< OPSETSIZE; i++) {
if (op == TestOp[i]) return i;
}
return 0;
}

char precede(char Aop, char Bop) {
return Prior[ReturnOpOrd(Aop,OPSET)][ReturnOpOrd(Bop,OPSET)];
}//ReturnOpOrd和precede组合，判断运算符优先级

float EvaluateExpression() {
// 算术表达式求值的算符优先算法。
// 设OPTR和OPND分别为运算符栈和运算数栈，OPSET为运算符集合。
SqStack<char> OPTR; // 运算符栈，字符元素
SqStack<float> OPND; // 运算数栈，实数元素
char TempData[20];
float Data,a,b;
char theta,c,x,Dr[2];

InitStack<SqStack<char>,char> (OPTR);
Push (OPTR, '#');
InitStack <SqStack<float>,float>(OPND);
strcpy(TempData,"\0");//将TempData置为空
c=getchar();
while (c!= '#' || GetTop<SqStack<char>,char>(OPTR)!= '#')
{
if (!In(c, OPSET))
{
Dr[0]=c;
Dr[1]='\0';//存放单个数
strcat(TempData,Dr);//将单个数连到TempData中，形成字符串
c=getchar();
if(In(c,OPSET))//如果遇到运算符，则将字符串TempData转换成实数，入栈，
并重新置空
{
Data=(float)atof(TempData);
Push(OPND, Data);
strcpy(TempData,"\0");
}
}
else
{ // 不是运算符则进栈
switch (precede(GetTop<SqStack<char>,char>(OPTR), c)) {
case '<': // 栈顶元素优先权低
Push(OPTR, c);
c=getchar();
break;
case '=': // 脱括号并接收下一字符
Pop(OPTR, x);
c=getchar();
break;
case '>': // 退栈并将运算结果入栈
Pop(OPTR, theta);
Pop(OPND, b);
Pop(OPND, a);
Push(OPND, Operate(a, theta, b));
break;
} // switch
}
} // while
return GetTop<SqStack<float>,float>(OPND);
} // EvaluateExpression

void main()
{
printf("请输入表达式（end #）：\n");
printf("%f\n",EvaluateExpression());
}

热心网友 时间：2023-05-11 19:18

#include<stdio.h>
#include<malloc.h>
#include<math.h>
#define Initsize 10
#define Increment 2
#define Max 1000

typedef char Selemtype;
typedef int Elemtype;

//定义元素是char型的栈
typedef struct
{
Selemtype *base;
Selemtype *top;
int size;
}Stack;

//定义元素是int型的栈
typedef struct
{
Elemtype *base;
Elemtype *top;
int size;
}Stack1;

//创建元素是char型的栈
void Init( Stack &S )
{
S.base = (Selemtype*) malloc (Initsize*sizeof(Selemtype));
S.top = S.base;
S.size = Initsize;
}

//创建元素是int型的栈
void Init1( Stack1 &S )
{
S.base = (Elemtype*) malloc (Initsize*sizeof(Elemtype));
S.top = S.base;
S.size = Initsize;
}

//字符型元素入栈
void Push( Stack &S,char c )
{
if( S.top - S.base >= S.size )
{
S.base = (Selemtype*) realloc (S.base,(Initsize+Increment)*sizeof(Selemtype));
S.top = S.base + S.size;
S.size += Increment;
}
*S.top = c;
S.top++;
}

//int型元素入栈
void Push1( Stack1 &S,int c )
{
if( S.top - S.base >= S.size )
{
S.base = (Elemtype*) realloc (S.base,(Initsize+Increment)*sizeof(Elemtype));
S.top = S.base + S.size;
S.size += Increment;
}
*S.top = c;
S.top++;
}

//删除栈Stack的栈顶元素
void Pop( Stack &S,char &c )
{
S.top--;
c = *S.top;
}

//删除栈Stack1的栈顶元素
void Pop1( Stack1 &S,int &c )
{
S.top--;
c = *S.top;
}

//得到栈Stack的栈顶元素
char Gettop( Stack S )
{
Selemtype *p;
p = S.top - 1;
return *p;
}

//得到栈Stack1的栈顶元素
int Gettop1( Stack1 S )
{
return *(S.top-1);
}

//判断c是否运算符集合中的元素
int In( char c )
{
if( c>='0' && c<='9' )
return 0;
}

char Precede( char in,char out )
{
char c;
int in1,out1;
switch( in )
{
case'+':
case'-':in1 = 3;
break;
case'*':
case'/':in1 = 5;
break;
case'(':
case')':in1 = 1;
break;
case'=':in1 = 0;
break;
}
switch( out )
{
case'+':
case'-':out1 = 2;
break;
case'*':
case'/':out1 = 4;
break;
case'(':out1 = 6;
break;
case')':out1 = 1;
break;
case'=':out1 = 0;
break;
}
if( in1>out1 )
c = '>';
else if( in1<out1 )
c = '<';
else
c = '=';
return c;
}

//表达式操作
char Operate(int a,char theta,int b)
{
switch(theta)
{
case'+':return a+b;
case'-':return a-b;
case'*':return a*b;
case'/':return a/b;
}
}

char OperandType()
{
char c[Max],c1[10],x,theta,*p;
int a,b,i,j,sum;
Stack OPTR;
Stack1 OPND;
Init(OPTR);
Push(OPTR,'=');
Init1(OPND);
scanf("%s",c);
p = c;
while( *p!='=' || Gettop(OPTR)!='=' )
{
if( !In(*p) )
{
sum = 0;
i = 0;
while( !In(*p) )
{
c1[i++] = *p++;

}
i--;
for( j=0;j<=i;j++ )
{
sum += (int)(( c1[j]-'0' )*pow( 10,i-j ));
}
Push1(OPND,sum);
}
if( In(*p) )
switch(Precede(Gettop(OPTR),*p))
{
case'<':
Push(OPTR,*p);
p++;
break;
case'=':
Pop(OPTR,x);
p++;
break;
case'>':
Pop(OPTR,theta);
Pop1(OPND,b);
Pop1(OPND,a);
Push1(OPND,Operate(a,theta,b));
break;
}
}
return Gettop1(OPND);
}

int main()
{
printf("%d\n",OperandType());
return 0;
}
看看是不是你想要的~