数据结构——表达式求值（二）

在上一篇的基础上，对程序作了修改，优化了部分代码

/*表达式求值*/

#include <stdio.h> 

#include <stdlib.h> 
#include <string.h> 
#define NULL 0 
#define OK 1
#define ERROR -1 
#define SIZE 100
#define ADDSIZE 20
typedef struct
{ 
int stacksize; 
char *base; 
char *top; 
} Stack; 
typedef struct{ 
int stacksize; 
int *base; 
int *top; 
} Stack2;
Stack OPTR;/* 定义运算符栈*/
Stack2 OPND; /* 定义操作数栈 */ 
int InitStack(Stack &s);
int InitStack2(Stack2 &s);
int In(char ch);
int Push(Stack &s, char e);
int Push2(Stack2 &s, int e);
char Pop(Stack &s);
char GetTop(Stack s);
int GetTop2(Stack2 s);
char Precede(char c1,char c2); 
int Operate(int a,char c,int b);
int EvalExpr(char c[255]);
int Empty(Stack s);
void main()
{ 
char expr[255];
printf("请输入正确的表达式以'#'结尾:\n"); 
gets(expr); 


InitStack(OPTR); /* 初始化运算符栈 */ 
Push(OPTR,'#'); /* 将#压入运算符栈 */ 
InitStack2(OPND); /* 初始化操作数栈 */ 
printf("表达式结果为:%d\n", EvalExpr(expr));
//return 0; 
}




int InitStack(Stack &s) //构造运算符栈
{ 
s.base = (char *)malloc(SIZE * sizeof(char));    
if(!s.base) return ERROR;    
s.top = s.base;    
s.stacksize = SIZE;    
return OK;
} 




int InitStack2(Stack2 &s) //构造操作数栈
{ 
s.base = (int *)malloc(SIZE * sizeof(int));    
if(!s.base) return ERROR;    
s.top = s.base;    
s.stacksize = SIZE;    
return OK;
} 




int In(char ch) //判断字符是否是运算符，运算符即返回1
{ 
return(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#'); 
} 




int Push(Stack &s, char e)
{ 
if(s.top - s.base >= s.stacksize)
{        
s.base = (char *) realloc(s.base, (s.stacksize + ADDSIZE) * sizeof(char)); 
 if(!s.base)
return ERROR;        
s.top = s.base + s.stacksize;        
s.stacksize += ADDSIZE;    
}    
*s.top++ = e;    
return OK;
}




int Push2(Stack2 &s, int e)
{ 
if(s.top - s.base >= s.stacksize)
{        
s.base = (int *) realloc(s.base, (s.stacksize + ADDSIZE) * sizeof(int)); 
 if(!s.base)
return ERROR;        
s.top = s.base + s.stacksize;        
s.stacksize += ADDSIZE;    
}    
*s.top++ = e;    
return OK;
}




char Pop(Stack &s)
{
char e;
    if(s.top == s.base)         
return ERROR;   
e = * --s.top;    
return e;
}
int Pop2(Stack2 &s)
{
int e;
    if(s.top == s.base)         
return ERROR;   
e = * --s.top;    
return e;
}




char GetTop(Stack s)
{ 
char e;
if(s.top==s.base)
return ERROR;
else
{
e=*(s.top-1);
}
return e; 
}




int GetTop2(Stack2 s) 
{ 
int e;
if(s.top==s.base)
return ERROR;
else
{
e=*(s.top-1);
}
return e; 
}
/* 判断运算符优先权，返回优先权高的 */ 


char Precede(char c1,char c2) 
{ 
int i=0,j=0; 
static char array[49]={
'>', '>', '<', '<', '<', '>', '>', 
'>', '>', '<', '<', '<', '>', '>', 
'>', '>', '>', '>', '<', '>', '>', 
'>', '>', '>', '>', '<', '>', '>', 
'<', '<', '<', '<', '<', '=', '!', 
'>', '>', '>', '>', '!', '>', '>', 
'<', '<', '<', '<', '<', '!', '='}; 
switch(c1) 
{ 
/* i为下面array的横标 */ 
case '+' : i=0;break; 
case '-' : i=1;break; 
case '*' : i=2;break; 
case '/' : i=3;break; 
case '(' : i=4;break; 
case ')' : i=5;break; 
case '#' : i=6;break; 
} 


switch(c2) 
{ 
/* j为下面array的纵标 */ 
case '+' : j=0;break; 
case '-' : j=1;break; 
case '*' : j=2;break; 
case '/' : j=3;break; 
case '(' : j=4;break; 
case ')' : j=5;break; 
case '#' : j=6;break; 
}
return (array[7*i+j]); /* 返回运算符 */ 
} 
/*操作函数 */ 
int Operate(int a,char c,int b) 
{ 
int s;
switch(c)
{
case'+':
s=a+b;
break;
case'-':
s=a-b;
break;
case'*':
s=a*b;
break;
case'/':
if(b!=0)
s=a/b;
else
printf("inputs error\n");
break;
}
return (s+'0');
} 


int Empty(Stack s)                /* 判断栈是否为空*/
{   
 if(s.top == s.base)
  return 1;
 else
  return 0;
} 
int EvalExpr(char c[255])//主要操作函数 
{
int i=0,s=0,a,b;
char x,theta;
    while(c[i]!='#'||GetTop(OPTR)!='#')
{
if(!In(c[i]))
{
if(c[i] >= '0' && c[i] <= '9')
{
s+=c[i]-'0';
while(!In(c[++i]))
{
s*=10;
s+=c[i]-'0';
}
Push2(OPND,s+'0');
s=0;
}
else
{
printf("你输入的表达式有误！\n");
return 0;
}
}
else
 switch(Precede(GetTop(OPTR),c[i])) 
{ 
 case '<': 
 Push(OPTR,c[i]); 
i++;
 break; 
 case '=': 
 x=Pop(OPTR); 
i++;
 break; 
 case '>': 
theta=Pop(OPTR); 
b=Pop2(OPND)-'0';
a=Pop2(OPND)-'0'; 
Push2(OPND,Operate(a,theta,b));
break;
} 
}
 return (GetTop2(OPND)-'0'); 
}