本文目录一览：
C语言编程（数据结构）:表达式求值
/*在TC2 和 VC6下都可以顺利运行。
做了一个下午。一定要用我这个噢。
有简单的输入错误检测。有完整的说明和
注释*/
#includestdio.h /*库文件包含*/
#includestring.h /*用于字符串操作*/
#includestdlib.h /*用于exit函数*/
/**************************************************************************
int check(char *c)
输入参数：
char *c: 输入的字符串
返回参数：
0：字符串中有不符合规定的字符
1: 字符串字符符合规定，没有不符合规定的字符.
功能：
检查字符串中有否除了 0-9, +,-,*,/,(,),之外的其他字符，
如果有，则返回0, 表示出现错误。
若没有，则返回1,表式字符串符合规定。
**************************************************************************/
int check(char *c)
{
int k=0;
while(*c!='\0')
{
if((*c='0' *c='9') || *c=='+' ||
*c=='-' || *c=='*' || *c=='/' ||
*c=='.' || *c=='(' || *c==')' )
{
}
else
{
printf("input error, there have the char not the math expression char!\n");
return 0;
}
if(*c=='(')
k++;
else if(*c==')')
k--;
c++;
}
if(k!=0)
{
printf("input error, there is not have correct bracket '()'!\n");
return 0;
}
return 1;
}
/**************************************************************************
void move(char *f, double *s,int p)
输入参数：
char *f : 运算符数组
double *s: 数值数组
int p: 当前运算符数组位置。
返回参数:
无
功能：
将当前已经完成运算的运算符消去，同时将数值数组的位置调整以进行下一次运算。
传入值p若为3
则当前符号的数组位置为3.
f[3]=f[3+1].......f[len-2]=f[len-1] f[len-1]='\0';
s[i]=s[i+1].......s[len-1]=s[len] 因为数值比运算符多一个。
***************************************************************************/
void move(char *f, double *s,int p)
{
int i=0,len=strlen(f);
for(i=p; ilen; i++) /*将已经运算过的符号，空出来的位置用后面的符号来填充，*/
{ /*即把乘和除号的位置用后面的加和减号填充*/
f[i]=f[i+1];
s[i]=s[i+1];
}
s[i]=s[i+1];
f[len-1]='\0';
}
/**************************************************************************
double convnum(char *c)
输入参数：
char *c :由数字和小数点组成的字符，用以转换成double型的数值。
返回参数：
num:返回转换好的值。
功能：
将输入的字符串先将其小数点以前的部分复制到temp[]数组中，
若有小数点，则将小数点之后的数值，也就是小数部分先进行计算,值存入num中
计算完成后，再对整数部分进行计算，值加上小数部分的值，存入num中。
***************************************************************************/
double convnum(char *c)
{
double num=0.0;
double a=1.0;
int i=0,p=0,len=0;
char temp[100];
int tempi=0;
int start=0;
int f=1; /*正负符号指示器，若为1则为正数，为－1，此数为负数*/
len=strlen©;
if(c[0]=='-')
{
start=1;
f=-1;
}
for(i=start; ilen; i++)
{
if(c[i]=='.')
{
p=i;
break;
}
temp[tempi++]=c[i]; /*将整数部分复制到temp[]中*/
}
temp[tempi]='\0';
if(p!=0)
{
for(i=p+1;ilen;i++) /*将小数部分计算出来*/
{
if(c[i]=='.') /*如果有多余的小数点，则表示输入错误*/
{
printf("there is more that one dot '.' in number!error!\n");
exit(0);
}
a=a*0.1;
num+=(a*(c[i]-48));
}
}
a=1.0;
len=strlen(temp); /*计算整数部分*/
for(i=len-1;i=0; i--)
{
num=num+(a*(temp[i]-48));
a*=10;
}
num=num*f;
return num;
}
/**************************************************************************
double good(char *c)
输入参数：
char *c :即将进行运算的字符串型数学表达式。如3.5+(2*3/5)
返回参数：
s[0]:计算结果将放入s[0]中
功能：
将输入的字符串中的数字分别调用convnum(char *c)函数进行数值变换，再将其依
次存入doulbe s[i]中，将加减乘除运算符依次存入字符串符号数组 char f[i]中，
然后如果遇到括号，则将括号内的字符串存入另一字符数组中，然后用此
good(char *c) 递归函数进行递归运算。 然后根据先乘除，后加减的顺序对已
存入数组的数值根 据存入字符串符号数组的运算符进行运算。结果存入s[0]中。
返回最终结果。
***************************************************************************/
double good(char *c) /*可递归函数*/
{ /*取得数值字符串，并调用convnum转换成double*/
char g[100],number[30]; /*g,保存当前的表达式串,number保存一个数的所有字符*/
char f[80]; /*保存所有的符号的堆栈*/
int fi=0; /*保存符号的位置指针*/
double s[80]; /*保存当前所有的数的一个堆栈*/
int si=0; /*保存数字位置指针*/
int k=0; /* 若k=1则表示有一对括号*/
int num=0,i=0; /*num保存新括号内的字符数,i 保存number里的字符位置*/
int cc=0; /*乘除符号数量*/
int jj=0; /*加减符号数量*/
while(*c!='\0')/*当p==1 和k==0时，表示已经把括号里的内容全部复制到g[100]中了*/
{
k=0;
num=0;
switch(*c)
{
case '+': /*当前字符为+-乘除时则表示*/
case '-':
case '*':
case'/':
f[fi++]=*c;
if(*c=='*' || *c=='/')
cc++;
else
jj++;
if(*(c-1)!=')')
{
number[i]='\0';
i=0;/*完成一个数字的复制，其位置指针i=0*/
s[si++]=convnum(number);
}
break;
case'(': /*有括号，则将当前括号作用范围内的全部字符保存，作为*/
k++; /*一个新的字符表达式进行递归调用good函数计算。*/
while(k0)
{
c++;
g[num]=*c;
num++;
if(*c==')')
{
k--;
}
else if(*c=='(')
{
k++;
}
}
g[num-1]='\0';
num=0;/*完成一个括号内容的复制，其位置指针num=0*/
s[si++]=good(g);
break;
default:
number[i++]=*c;
if(*(c+1)=='\0')
{ number[i]='\0';
s[si++]=convnum(number);
}
break;
}
c++;
}
f[fi]='\0';
i=0;
while(cc0)
{
switch(f[i])
{
case '*': cc--;
s[i+1]=s[i]*s[i+1];
move(f,s,i);
break;
case '/': cc--;
s[i+1]=s[i]/(float)s[i+1];
move(f,s,i);
break;
default:
i++;
break;
}
}
i=0;
while(jj0)
{
switch(f[i])
{
case '+': s[i+1]=s[i]+s[i+1];
jj--;
move(f,s,i);
break;
case '-': s[i+1]=s[i]-s[i+1];
jj--;
move(f,s,i);
break;
default:
printf("operator error!");
break;
}
}
return s[0];
}
void main()
{
char str[100];
double sum=0;
int p=1;
while(1)
{
printf("enter expression: enter 'exit' end of program\n");
scanf("%s",str);
p=strcmp(str,"exit");
if(p==0)
break;
p=check(str);
if(p==0)
continue;
sum=good(str);
printf("%s=%f",str,sum);
printf("\n");
}
printf("good bye!\n");
}
例：
enter expression: enter 'exit' end of program
3.5+(12.3*15+8-(3/2+1))*2+(3.2*3-5)/6(输入)
3.5+(12.3*15+8-(3/2+1))*2+(3.2*3-5)/6=384.266667
enter expression: enter 'exit' end of program
china(输入)
input error, there have the char not the math expression char!
enter expression: enter 'exit' end of program
exit(输入)
good bye!
用C语言编写程序“算术表达式求值”
#include stdio.h
#include math.h
enum state
;
int ctoi( char c)
bool isNum( char a)
bool isOp(char op)
{
switch(op)
{
case '+':
return true;
break;
case '-':
return true;
break;
case '*':
return true;
break;
case '/':
return true;
break;
default:
return false;
break;
}
}
bool isDot(char dot)
int checkString( char str[], double *a, double * b, char* op, int num)
{
enum state s = BEGIN;
int a_i = 0;
int b_i = 0;
double num1 = 0;
double num2 = 0;
int pointNum = 0;
for( int i = 0; i num; ++i)
{
if(str[i] == ' ')continue;
switch(s)
{
case BEGIN:
if(isNum(str[i]))
elses = ERROR;
break;
case P2:
if(isNum(str[i]))
else if(isDot(str[i]))
{
s = P3;
}
else if(isOp(str[i]))
{
*op = str[i];
s = P5;
}
else
s = ERROR;
break;
case P3:
if(isNum(str[i]))
{
num1 = num1 + ctoi(str[i]) * pow(0.1, ++pointNum) ;
s = P4;
}
else
s = ERROR;
break;
case P4:
if(isNum(str[i]))
{
num1 = num1 + ctoi(str[i]) * pow(0.1, ++pointNum);
s = P4;
}
else if(isOp(str[i]))
{
*op = str[i];
s = P5;
}
else
s = ERROR;
break;
case P5:
if(isNum(str[i]))
{
num2 = num2 * 10 + ctoi(str[i]);
s = P6;
}
else
s = ERROR;
break;
case P6:
pointNum = 0;
if(isNum(str[i]))
{
num2 = num2 * 10 + ctoi(str[i]);
s = P6;
}
else if(isDot(str[i]))
{
s = P7;
}
else
s = END;
break;
case P7:
if(isNum(str[i]))
{
num2 = num2 + ctoi(str[i]) * pow(0.1, ++pointNum);
s = P8;
}
else
s = END;
break;
case 8:
if(isNum(str[i]))
{
num2 = num2 + ctoi(str[i]) * pow(0.1, ++pointNum);
s = P8;
}
else if(isOp(str[i]))
{
s = END;
}
else
s = END;
break;
case ERROR:
printf("express error. \n");
break;
}
if (s == END || s == ERROR)
break;
}
if(s==END)
else
}
int main()
{
char op;
double a;
double b;
char string[128] = ;
scanf("%s", string);
printf("the expression you input is : %s. \n", string);
getchar();
if (-1 == checkString(string, a, b, op, 128))
{
printf("error occur while checking expression. Be sure no space in your expression when input\n");
getchar();
return 0;
}
double result;
switch(op)
{
case '+':
result = a + b;
break;
case '-':
result = a - b;
break;
case '*':
result = a * b;
break;
case '/':
if(b != 0)
result = a / b;
else
{
printf(" error! %d/%d", a, b);
return -1;
}
break;
default:
printf("undefined expression.\n");
break;
}
printf("%f %c %f = %f\n", a, op, b, result);
return 0;
}
C语言表达式求值
//表达式求值
//By:jimly
//10/10/2009
//例如：输入2+2（4-6*3）=
//以"="结束,然后回车即出结果
#include stdio.h
#include conio.h
#include windows.h
#include assert.h
typedef float ElemType;
typedef struct Stack
{
ElemType *base; // 栈基址
ElemType *top; // 栈顶
int stacksize; // 栈存储空间的尺寸
} SqStack;
/*------------------------------------------------------------
// 栈的基本操作
------------------------------------------------------------*/
bool InitStack(SqStack *S);
bool InitStack(SqStack *S);
void DestroyStack(SqStack *S);
bool StackEmpty(SqStack S);
int StackLength(SqStack S);
ElemType GetTop(SqStack S, ElemType *e);
void StackTraverse(SqStack S, void (*fp)(ElemType));
bool Push(SqStack *S, ElemType e);
bool Pop(SqStack *S, ElemType *e);
/*------------------------------------------------------------
// 表达式求值的操作函数定义
------------------------------------------------------------*/
char Precede(char A1,char A2);
ElemType Operate(ElemType a,ElemType theta,ElemType b);
bool In(char c,char op[]);
ElemType EvaluateExpression();
void Menu();//////////////////////////////////////////////
// Eval_exdivssion.cpp 表达式求值实现函数 //
//////////////////////////////////////////////
/*------------------------------------------------------------
操作目的： 判定运算符栈的栈顶运算符A1和读入的运算符A2之间优先关系的函数
初始条件： 无
操作结果： 判断出优先关系
函数参数：
char A1 运算符
char A2 运算符
返回值：
char 大小关系
------------------------------------------------------------*/
char Precede(char A1,char A2)
{
if (A1 == '+' || A1 == '-')
{
if (A2 == '+' || A2 == '-' || A2 == ')' || A2 == '=')
{
return '';
}
else
return '';
}
if (A1 == '*' || A1 == '/')
{
if (A2 == '(')
{
return '';
}
else
return '';
}
if (A1 == '(')
{
if (A2 == ')')
{
return '=';
}
if (A2 == '=')
{
return 'E';
}
else
return '';
}
if (A1 == ')')
{
if (A2 == '(')
{
return 'E';
}
if (A2 == '=')
{
return 'E';
}
else
return '';
}
if (A1 == '=')
{
if (A2 == '=')
{
return '=';
}
else
return '';
}
else
return '=';
}
/*------------------------------------------------------------
操作目的： 二元运算a与b的函数
初始条件： 无
操作结果： 返回运算结果
函数参数：
ElemType a 操作数
ElemType theta 操作符
ElemType b 操作数
返回值：
ElemType 运算结果
------------------------------------------------------------*/
ElemType Operate(ElemType a,ElemType theta,ElemType b)
{
switch(char(theta))
{
case '+':
return a += b;
break;
case '-':
return a -= b;
break;
case '*':
return a *= b;
break;
case '/':
if(b==0)
{
printf("除数不能为0！！\n");
exit(0);
}
return a /= b;
break;
} return 0;
}
/*------------------------------------------------------------
操作目的： 判断字符c是否属于运算符集合op
初始条件： 无
操作结果： 返回判断结果
函数参数：
char c 要判断的字符
char op[] 运算符集合
返回值：
bool 属于返回true 否则返回false
------------------------------------------------------------*/
bool In(char c,char op[])
{
for (int i = 0;i7;i++)
{
if (op[i] == c)
return true;
}
return false;
}
/*------------------------------------------------------------
操作目的： 算术表达式求值的运算符优先算法
初始条件： 无
操作结果： 返回表达式的值
函数参数：
无
返回值：
ElemType 运算结果
------------------------------------------------------------*/
ElemType EvaluateExpression()
{
SqStack OPTR; //运算符栈
SqStack OPND; //运算数栈
char Ct = '='; //判断是否结束的标识
int i = 0,j = 1;
ElemType e = 0,t = 0,c;
char op[7] = {'+','-','*','/','(',')','='}; InitStack(OPTR); //初始化
Push(OPTR,Ct);
InitStack(OPND); //初始化 c = (float)getchar();
while (c!='=' || GetTop(OPTR,e)!='=')
{
if (!In((char)c,op)) //不是运算e符进栈
{
while(!In((char)c,op)) //可以是几位数
{
t = t*10+(c-48);
c = (float)getchar();
}
Push(OPND,t);
t = 0;
} else
{
switch (Precede((char)GetTop(OPTR,e),(char)c))
{
case ''://栈顶元素优先权低
Push(OPTR,c);
c = (float)getchar();
break;
case '='://脱括号并接受下个字符
ElemType x;
Pop(OPTR,x);
c = (float)getchar();
break;
case ''://退栈并将运算结果入栈
ElemType b,theta,a;
Pop(OPTR,theta);
Pop(OPND,b);
Pop(OPND,a);
Push(OPND,Operate(a,theta,b));
break;
case 'E':
printf("括号不匹配！！\n");
exit(0);
break;
}
}
}
ElemType tem = GetTop(OPND,e);
DestroyStack(OPND);
DestroyStack(OPTR);
return tem;
}/***
*DynaSeqStack.cpp - 动态顺序栈，即栈的动态顺序存储实现
****/
const int STACK_INIT_SIZE = 100; // 初始分配的长度
const int STACKINCREMENT = 10; // 分配内存的增量
/*------------------------------------------------------------
操作目的： 初始化栈
初始条件： 无
操作结果： 构造一个空的栈
函数参数：
SqStack *S 待初始化的栈
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool InitStack(SqStack *S)
{
assert(S != NULL);
S-base = (ElemType *)malloc(sizeof(ElemType) * STACK_INIT_SIZE);
if(S-base == NULL) return false; S-top = S-base;
S-stacksize = STACK_INIT_SIZE; return true;
}/*------------------------------------------------------------
操作目的： 销毁栈
初始条件： 栈S已存在
操作结果： 销毁栈S
函数参数：
SqStack *S 待销毁的栈
返回值：
无
------------------------------------------------------------*/
void DestroyStack(SqStack *S)
{
assert(S != NULL); free(S-base);
S-top = S-base = NULL;
}/*------------------------------------------------------------
操作目的： 判断栈是否为空
初始条件： 栈S已存在
操作结果： 若S为空栈，则返回true，否则返回false
函数参数：
SqStack S 待判断的栈
返回值：
bool 是否为空
------------------------------------------------------------*/
bool StackEmpty(SqStack S)
{
assert((S.base != NULL) (S.top != NULL));
return(S.base == S.top);
}/*------------------------------------------------------------
操作目的： 得到栈的长度
初始条件： 栈S已存在
操作结果： 返回S中数据元素的个数
函数参数：
SqStack S 栈S
返回值：
int 数据元素的个数
------------------------------------------------------------*/
int StackLength(SqStack S)
{
assert((S.base != NULL) (S.top != NULL));
return(S.top-S.base);
}/*------------------------------------------------------------
操作目的： 得到栈顶元素
初始条件： 栈S已存在
操作结果： 用e返回栈顶元素
函数参数：
SqStack S 栈S
ElemType *e 栈顶元素的值
返回值：
bool 操作是否成功
------------------------------------------------------------*/
ElemType GetTop(SqStack S, ElemType *e)
{
assert((S.base != NULL) (S.top != NULL));
if(StackEmpty(S)) return false; *e = *(S.top-1);
return *e;
}/*------------------------------------------------------------
操作目的： 遍历栈
初始条件： 栈S已存在
操作结果： 依次对S的每个元素调用函数fp
函数参数：
SqStack S 栈S
void (*fp)() 访问每个数据元素的函数指针
返回值：
无
------------------------------------------------------------*/
void StackTraverse(SqStack S, void (*fp)(ElemType))
{
assert((S.base != NULL) (S.top != NULL));
for(; S.baseS.top; S.base++) (*fp)(*S.base);
}/*------------------------------------------------------------
操作目的： 压栈——插入元素e为新的栈顶元素
初始条件： 栈S已存在
操作结果： 插入数据元素e作为新的栈顶
函数参数：
SqStack *S 栈S
ElemType e 待插入的数据元素
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool Push(SqStack *S, ElemType e)
{
if (S-top - S-base=S-stacksize)
{
S-base = (ElemType *)realloc(S-base,(S-stacksize + STACKINCREMENT) * sizeof(ElemType));
if (!S-base)
exit(0);
S-top = S-base + S-stacksize;
S-stacksize += STACKINCREMENT;
}
*S-top++ = e; return true;
}/*------------------------------------------------------------
操作目的： 弹栈——删除栈顶元素
初始条件： 栈S已存在且非空
操作结果： 删除S的栈顶元素，并用e返回其值
函数参数：
SqStack *S 栈S
ElemType *e 被删除的数据元素值
返回值：
bool 操作是否成功
------------------------------------------------------------*/
bool Pop(SqStack *S, ElemType *e)
{
if(S == NULL) return false;
assert((S-base != NULL) (S-top != NULL));
if(StackEmpty(*S)) return false; *e = *(--S-top);
return true;
}//////菜单///////
void Menu()
{
printf("表达式求值模拟程序\n\n");
printf("功能菜单：\n");
printf("==============\n");
printf("[1] 输入表达式并求值\n");
printf("[0] 退出 \n");
printf("==============\n");
printf("请输入你的选择(0~1)（以回车结束）：");
}///////// 主函数 ///////////
//////////////////////////////
int main()
{
char ch = ' ',tp; do
{
system("cls");
Menu();
ch = getchar();
if (ch == '0')
break;
tp = getchar();
printf("请输入一个表达式（最后输入”=“,然后回车出结果）：");
printf("这个表达式结果为：%g\n",EvaluateExpression());
tp = getchar();
printf("任意键继续...");
getch();
} while (true); return 0;
}//end
算术表达式求值 C语言
cludeiostream.h
//#define MaxLen 100//存储空间
int tran(char str[], char expr[]) //将中缀表达式转换成后缀表达式 if(tran(str,expr)==0)//原来表达式，后缀表达式
{
int st[100]; //转化过程使用的过度栈
char ch;
int i=0,exindex=0,stindex=-1; //i是str下标，exindex是expr下标，stindex是st下标
while((ch=str[i++])!='\0')
{
if(ch='0' ch='9') //判断是数字
{
expr[exindex]=ch; //压栈
exindex++; //栈顶指针上移
while((ch=str[i++])!='\0' ch='0' ch='9') //其它位依次入栈
{
expr[exindex]=ch;
exindex++;
}
i--; //str原算术表达式栈向下遍历
expr[exindex]='#'; //以特殊字符“#”表示结束
exindex++;
}
else if(ch=='(') //判断为左括号
{
stindex++;
st[stindex]=ch;
}
else if(ch==')') //判断为右括号
{
while (st[stindex]!='(')
{
expr[exindex]=st[stindex];
stindex--; //依次弹出
exindex++;
}
stindex--;//'('出栈
}
else if(ch=='+' || ch=='-')//判断为加减号
{
while(stindex=0 st[stindex]!='(')
{
expr[exindex]=st[stindex];
stindex--;
exindex++;
}
stindex++;
st[stindex]=ch;
}
else if (ch=='*' || ch=='/')//判断为乘除号
{
while(st[stindex]=='*' || st[stindex]=='/')
{
expr[exindex]=st[stindex];
stindex--;
exindex++;
}
stindex++;
st[stindex]=ch;
}
}
while (stindex=0)//将栈中所有运算符依次弹出存入expr栈中
{
expr[exindex]=st[stindex];
exindex++;
stindex--;
}
expr[exindex]='\0';
return 1;
}
int compvalue(char expr[],int *n)
{
int st[100],d; //st为数栈
char ch;
int exindex=0,stindex=-1; //exindex是expr下标，stindex是st的下标
while((ch=expr[exindex++])!='\0')
{
if(ch='0'ch='9')//将数字字符转换成数字
{
d=0;
do
{
d=10*d+ch-'0';
}
while((ch=expr[exindex++])!='#');
stindex++;
st[stindex]=d;//数字进栈
}
else//运算符操作
{
switch(ch)
{
case'+':st[stindex-1]=st[stindex-1]+st[stindex];
break;
case'-':st[stindex-1]=st[stindex-1]-st[stindex];
break;
case'*':st[stindex-1]=st[stindex-1]*st[stindex];
break;
case'/':
if(st[stindex]!=0)
{ st[stindex-1]=st[stindex-1]/st[stindex]; }
else return 0; //除0错误!
break;
}
stindex--;
}
}
(*n)=st[stindex];
return 1;
}
void main()
{
char str[100]; //存储原来算术表达式
char expr[100]; //存储转换成的后缀表达式
int n;
cout"输入算术表达式:"endl;
cinstr;
if(tran(str,expr)==0)
{
cout"原算术表达式不正确!"endl;
}
else
{
cout"转换成后缀表达式输出:"endlexprendl;
if(compvalue(expr,n)==1)
{
cout"表达式求值:"endlnendl;
}
else
{
cout"计算错误!"endl;
}
}
如何用C语言数据结构的格式实现简单的算术表达式求值程序
用栈把中缀表达式(输入的式子）按优先级转为后缀表达式（逆波兰式，即运算符在前，操作数在后），再利用栈变计算边保存结果用于下一步计算，最后算出式子的答案
以下代码输入一个式子（以
=
作为输入结束标志），输出结果，负数如-3用0-3表示，支持高位运算
#include
stdio.h
#include
stdlib.h
#include
math.h
#include
malloc.h
#define
OK
1
#define
ERROR
-1
typedef
char
SElemType;
typedef
char
Status;
#define
STACK_INIT_SIZE
100000
#define
STACKINCREMENT
2
struct
SqStack
{
SElemType
*base;
SElemType
*top;
int
stacksize;
};
struct
SqStack1
{
int
*base;
int
*top;
int
stacksize;
};
SqStack
OPTR;
SqStack1
OPND;
char
Precede(char
c1,char
c2)
{
if(c1=='+'
||
c1=='-')
{
if(c2=='+'
||
c2=='-'
||
c2==')'
||
c2=='=')
return
'';
else
return
'';
}
else
if(c1=='*'
||
c1=='/')
{
if(c2=='(')
return
'';
else
return
'';
}
else
if(c1=='(')
{
if(c2==')')
return
'=';
else
return
'';
}
else
if(c1==')')
return
'';
else
if(c1=='=')
{
if(c2=='=')
return
'=';
else
return
'';
}
else
return
'\0';
}
int
In(char
c)
{
if(c=='+'
||
c=='-'
||
c=='*'
||
c=='/'
||
c=='('
||
c==')'
||
c=='=')
return
1;
else
return
0;
}
int
Operrate(int
m,char
b,int
n)
{
switch(b)
{
case
'+':return
m+n;
case
'-':return
m-n;
case
'*':return
m*n;
case
'/':return
m/n;
}
return
0;
}
//操作数
int
InitStack1(SqStack1
S)
{
S.base=(int
*)malloc(STACK_INIT_SIZE*sizeof(int));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return
OK;
}
int
Push1(SqStack1
S,int
e)
{
if(S.top-S.base=S.stacksize)
{
S.base=(int
*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREMENT;
}
*S.top++=e;
return
OK;
}
int
Pop1(SqStack1
S,int
e)
{
if(S.top==S.base)
return
ERROR;
e=*
--S.top;
return
OK;
}
int
GetTop1(SqStack1
S)
{
if(S.top==S.base)
return
ERROR;
return
*(S.top-1);
}
//算符
int
InitStack(SqStack
S)
{
S.base=(SElemType
*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return
OK;
}
int
Push(SqStack
S,SElemType
e)
{
if(S.top-S.base=S.stacksize)
{
S.base=(SElemType
*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREMENT;
}
*S.top++=e;
return
OK;
}
int
Pop(SqStack
S,SElemType
e)
{
if(S.top==S.base)
return
ERROR;
e=*
--S.top;
return
OK;
}
Status
GetTop(SqStack
S)
{
if(S.top==S.base)
return
ERROR;
return
*(S.top-1);
}
int
Calculate()
{
char
c,theta,p;
int
a,b,i=0,ans,x;
InitStack(OPTR);
Push(OPTR,'=');
InitStack1(OPND);
c=getchar();
while(c!='='
||
GetTop(OPTR)!='=')
{
if(!In(c)
c='0'
c='9')
{
Push1(OPND,c-'0');
c=getchar();
while(c='0'
c='9')
{
Pop1(OPND,x);
Push1(OPND,x*10+c-'0');
c=getchar();
}
}
else
if(In(c))
{
switch(Precede(GetTop(OPTR),c))
{
case
'':
Push(OPTR,c);
c=getchar();
break;
case
'=':
Pop(OPTR,p);
c=getchar();
break;
case
'':
Pop(OPTR,theta);
Pop1(OPND,b);
Pop1(OPND,a);
ans=Operrate(a,theta,b);
Push1(OPND,ans);
break;
}
}
else
{
c=getchar();
}
}
return
GetTop1(OPND);
}
int
main()
{
int
ans;
ans=Calculate();
printf("%d\n",ans);
return
0;
}
