表达式求值--数据结构C语言算法实现

这篇博客介绍的表达式求值是用C语言实现的，只使用了c++里面的引用。

数据结构课本上的一个例题，但是看起来很简单，实现却遇到了很多问题。

这个题需要构建两个栈，一个用来存储运算符OPTR， 一个用来存储数字OPND。

但是，数字和运算符都定义成字符型栈吗？

出现了问题，当运算结果或中间结果为负时，没有办法存储。而且只能运算0~9之间的数字结果也只能是0~9之间。

那就运算符栈为字符栈， 数字栈为数值型栈，在存储时将表达式中的字符转化成数值进行存储。

但是，如果我们不用c++里面的stack进行栈的定义，而是用C语言进行实现，这种方法实现起来好像也没有这么简单，代码很多。两种栈的元素类型不一样，操作很繁琐。

怎么办呢， 我想可以用char类型的ASCII码数值来表示数值，两个栈都定义为字符栈。

数值进行存储时，将读入的字符型变量值减去0的ASCII码值  c - '0' ，然后压栈。

但这样做也有缺陷，应为C语言中char类型只有8位， 那这种方法实现的表达式求值，其结果和中间值的取值范围[ -128, 127] 。

我们主要是学习栈的实现和应用，其实对于这个题来说已经足够了。

下面附上代码的实现：

 #include <stdio.h>
 #include <stdlib.h>

 #define ElemType char
 #define STACKINCEMENT 10
 #define STACK_INIT_SIZE 50

 #define Status int
 #define OK 1
 #define ERROR 0
 #define OVERFLOW -2

 typedef struct{
     ElemType *base;
     ElemType *top;
     int stacksize;
 }SqStack;

 Status InitStack(SqStack &S){
     S.top = S.base = (ElemType *)malloc(sizeof(ElemType) * STACK_INIT_SIZE);
     if(!S.top)
         exit(OVERFLOW);
     S.stacksize = STACK_INIT_SIZE;
     return OK;
 }//InitStack

 Status Push(SqStack &S, ElemType e){
     if(S.top - S.base == S.stacksize){
         S.base = (ElemType *)realloc(S.base, sizeof(ElemType) *
                                    (S.stacksize + STACKINCEMENT));
         if(!S.base) exit(OVERFLOW);
         S.top = S.base + S.stacksize;
         S.stacksize += STACKINCEMENT;
     }
     *S.top++ = e;
     return OK;
 }//Push

 Status Pop(SqStack &S, ElemType &e){
     if(S.base == S.top) return ERROR;

     e = *--S.top;
     return OK;
 }//Pop

 ElemType GetTop(SqStack S){
     if(S.base == S.top) return ERROR;
     return *--S.top;
 }//GetTop

 Status In(ElemType c){
     if(c=='+'||c=='-'||c=='*'||c=='/'||c=='#'||c=='('||c==')'||c=='['||c==']')
         return ;
     else
         return ;
 }//In

 char Precede(ElemType a, ElemType b){
     if(a=='+'||a=='-'){
         if(b=='+'||b=='-'||b=='>'||b=='#'||b==')'||b==']')
             return '>';
         else return '<';
     }
     if(a=='*'||a=='/'){
         if(b=='('||b=='[')
             return '<';
         else return '>';
     }
     if(a=='('){
         if(b==')')
             return '=';
         else return '<';
     }
     if(a=='['){
         if(b==']')
             return '=';
         else return '<';
     }
     if(a=='#'){
         if(b=='#')
             return '=';
         else return '<';
     }
 }//Precede

 ElemType Operate(ElemType a, ElemType x, ElemType b){
     switch (x){
     case '+':
         return a  + b;
     case '-':
         return a  - b;
     case '*':
         return a * b;
     case '/':
         return a / b;
     }
 }//Operator

 ElemType EvaluateExpression(){
     SqStack OPTR, OPND;
     InitStack(OPTR); //操作符
     Push(OPTR, '#');
     InitStack(OPND); //操作数

     char x, c[];
     gets(c);
     int i=;
     while(c[i] != '#' || GetTop(OPTR)!='#'){
         if(!In(c[i])) {
             if(i> && (c[i-]>''&& c[i-]<='')){
                 Pop(OPND, x);
                 Push(OPND, *x + c[i] - '');
             }
             else Push(OPND, c[i] - '');
             i++;
         }
         else
             switch(Precede(GetTop(OPTR), c[i])){
             case '<':
                 Push(OPTR, c[i]);
                 i++;
                 break;
             case '=':
                 Pop(OPTR, x);
                 i++;
                 break;
             case '>':
                 Pop(OPTR, x);
                 ElemType a, b;
                 Pop(OPND, b); Pop(OPND, a);
                 Push(OPND, Operate(a, x, b));
                 break;
             }
     }
     return GetTop(OPND);
 }//EvaluateExpression

 int main(){
     SqStack S;
     InitStack(S);
     printf("%d",EvaluateExpression());

     return ;
 }