表达式求值

/*程序的说明见清华大学出版社<<数据结构(c语言版)>>*/

#include<stdlib.h>
#include<stdio.h>
#define stack_init_size 40
#define stackincrement 20
#define OK 1
#define FALSE 0
typedef struct{
    int *base;
    int *top;
    int stacksize;
}s_stack;
typedef struct{
    char *base;
    char *top;
    int stacksize;
}f_stack;
static char OP[7][7]=
    {
        {'>','>','<','<','<','>','>'},{'>','>','<','<','<','>','>'},
        {'>','>','>','>','<','>','>'},{'>','>','>','>','<','>','>'},
        {'<','<','<','<','<','=',' '},{'>','>','>','>',' ','>','>'},
        {'<','<','<','<','<',' ','='}
    };
int in(char c) /*判断是否为运算符*/
{
int i;
char a[]="+-*/()#";
for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
  if(c==a ) return i+1;
return 0;
}
int s_initial(s_stack *s)//操作数栈初始化
{
    s->base=(int *)malloc(stack_init_size*sizeof(int));
if(!s->base) exit(0);
s->top=s->base;
s->stacksize=stack_init_size;
return OK;
}
int f_initial(f_stack *f)//运算符栈初始化
{
    f->base=(char *)malloc(stack_init_size*sizeof(char));
if(!f->base) exit(0);
f->top=f->base;
f->stacksize=stack_init_size;
return OK;
}
void s_push(s_stack *s,int e)
{
     if(s->top-s->base>=s->stacksize)
     {
         s->base=(int *)realloc(s->base,(s->stacksize+stackincrement)*sizeof(int));
         if(!s->base) exit(0);
         s->top=s->base+s->stacksize;
         s->stacksize+=stackincrement;
     }
    *(s->top)=e; s->top++;
}
void  f_push(f_stack *f,char e)
{
     if(f->top-f->base>=f->stacksize)
     {
         f->base=(char *)realloc(f->base,(f->stacksize+stackincrement)*sizeof(char));
         if(!f->base) exit (0);
         f->top=f->base+f->stacksize;
         f->stacksize+=stackincrement;
     }
     *(f->top)=e;f->top++;
}
int  f_pop(f_stack *f,char *e)
{
     if(f->base==f->top)
     {
   return FALSE;  
  }
     *e=*(--f->top);
  return OK;
}
int  s_pop(s_stack *s,int *e)/*操作数出栈*/
{
if(s->top==s->base)
     {
   return FALSE;     }

     *e=*(--s->top);
  return OK;
}
int s_gettop(s_stack *s)
{
    return *(s->top-1);
}
char f_gettop(f_stack *f)
{
    return *(f->top-1);
}
char Precede(char theta1,char theta2)/*比较运算符优先级*/
{
    return OP[in(theta1)-1][in(theta2)-1];
}
int operate(int p,char op,int q) /*计算*/
{
        switch(op)
    {
        case '+': return q+p;
        case '-': return q-p;
        case '*': return q*p;
        case '/': return q/p;
    }
}
int EvaluateExpression(s_stack *OPND,f_stack *OPTR)
{
char c,op,x;
int a,b;
s_initial(OPND);f_initial(OPTR);
f_push(OPTR,'#');
c=getchar();
while(c!='#' ||f_gettop(OPTR)!='#')
{
        if(!in(c)) /*为操作数*/
        {
   s_push(OPND,c-'0');
   c=getchar();
        }
        else
  {
   switch(Precede(f_gettop(OPTR),c))
   {
     case '<':
       f_push(OPTR,c);c=getchar();
     break;
     case '=':
      f_pop(OPTR,&op);
      c=getchar();
       break;
     case '>':
       s_pop(OPND,&a);
       s_pop(OPND,&b);
       f_pop(OPTR,&op);
       s_push(OPND,operate(a,op,b));/*没有检查除0的错误*/
       break;
   }
  }
}
return s_gettop(OPND);
}
int main()
{
    s_stack s;
    f_stack f;
printf("%d /n",EvaluateExpression(&s,&f));
}