#include<stdio.h>
#define OPSETSIZE 7
#define Size 50
typedef struct
{
    char stack[Size];
    int top;
}StackChar;
typedef struct
{
    float stack[Size];
    int top;
}StackFloat;
unsigned char Prior[7][7] =
{     // 表3.1  算符间的优先关系
        '>','>','<','<','<','>','>',
      '>','>','<','<','<','>','>',
      '>','>','>','>','<','>','>',
      '>','>','>','>','<','>','>',   
      '<','<','<','<','<','=',' ',
      '>','>','>','>',' ','>','>',
      '<','<','<','<','<',' ','='
};        
float Operate(float a, unsigned char theta, float b);
char OPSET[OPSETSIZE]={'+' , '-' , '*' , '/' ,'(' , ')' , '#'};
int In(char Test,char* TestOp);
char precede(char Aop, char Bop);
void InitStackchar(StackChar *s);
void InitStackfloat(StackFloat *s);
void Pushchar(StackChar *s,char ch);
void Pushfloat(StackFloat *s,int t);
char GetTopchar(StackChar *s);
float GetTopfloat(StackFloat *s);
void Popchar(StackChar *s, char ch);
void Popfloat(StackFloat *s, float t);
        
float EvaluateExpression()
{  // 算法3.4
   // 算术表达式求值的算符优先算法。
   // 设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合。
   StackChar   OPTR;    // 运算符栈，字符元素
   StackFloat  OPND;    // 运算数栈，实数元素
   char TempData[20];
   float Data,a,b;
   char theta,c,x;
   
   InitStackchar(&OPTR);
   Pushchar (&OPTR, '#');
   InitStackfloat(&OPND);
   c = getchar();
   while (c!= '#' || GetTopChar(&OPTR)!= '#')
   {
      if (!In(c, OPSET))
      {
          Pushchar(&OPND,c);
          c=getchar();
      }
      else
      {   // 不是运算符则进栈
         switch (precede(GetTopChar(&OPTR), c))
         {
            case '<':   // 栈顶元素优先权低
                 Pushchar(&OPTR, c);  
                 c=getchar();
                 break;
            case '=':   // 脱括号并接收下一字符
                 Popchar(&OPTR, x);   
                 c=getchar();
                 break;
            case '>':   // 退栈并将运算结果入栈
                 Popchar(&OPTR, theta);
                 Popfloat(&OPND, b);  
                 Popfloat(&OPND, a);                     
                 Pushfloat(&OPND, Operate(a, theta, b));
                 break;
         } // switch
      }
   } // while
   return GetTopFloat(&OPND);
} // EvaluateExpression

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 In(char Test,char* TestOp)
{
   int Find=0,i;
   for (i=0; i< OPSETSIZE; i++)
   {
      if (Test == TestOp[i])
          Find= 1;
   }
   return Find;
}


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)];
}

void InitStackchar(StackChar *s)
{
    s->top=-1;
}

void InitStackfloat(StackFloat *s)
{
    s->top=-1;
}

void Pushchar(StackChar *s,char ch)
{
        s->top++;
        s->stack[s->top]=ch;
}

void Pushfloat(StackFloat *s,int t)
{
        s->top++;
        s->stack[s->top]=t;
}

char GetTopchar(StackChar *s)
{
    char ch='0';
    if(s->top==-1)
        return ch;
    else
    {
        ch=s->stack[s->top];
        return ch;
    }
}

float GetTopfloat(StackFloat *s)
{
    float t;
    t=s->stack[s->top];
    return t;
}

void Popchar(StackChar *s, char ch)
{
    ch=s->stack[s->top];
    s->top--;
}

void Popfloat(StackFloat *s, float t)
{
    t=s->stack[s->top];
    s->top--;
}
void main()
{
    float x;
    printf("请输入一个表达式:\n");
    x=EvaluateExpression();
    printf("表达式的结果是：%f\n",x);
}