数据结构-表达式求值

程序代码如下：

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

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OVERFLOW -2
#define OK 1
#define ERROR 0

typedef char SElemType;
typedef int ElemType;

//栈结构体
typedef struct {
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStackOptr;//运算符栈

typedef struct {
    ElemType *base;
    ElemType *top;
    int stacksize;
}SqStackOpnd;//运算数栈

//运算符栈
int InitStackOptr(SqStackOptr *S);//初始化栈
SElemType GetTopOptr(SqStackOptr *S);//取得栈顶元素
int PushOptr(SqStackOptr *S,SElemType e);//入栈
int PopOptr(SqStackOptr *S,SElemType *e);//删除栈中的元素
int DestoryStackOptr(SqStackOptr *S);//销毁栈
//运算数栈
int InitStackOpnd(SqStackOpnd *S);//初始化栈
ElemType GetTopOpnd(SqStackOpnd *S);//取得栈顶元素
int PushOpnd(SqStackOpnd *S,SElemType e);//入栈
int PopOpnd(SqStackOpnd *S,SElemType *e);//删除栈中的元素
int DestoryStackOpnd(SqStackOpnd *S);//销毁栈
//表达式求值
ElemType EvaluateExpression(SqStackOptr *OPTR,SqStackOpnd *OPND);//输入表达式并计算表达式的值
SElemType Precede(char topc,char c);//判断运算符优先级
ElemType Operate(SElemType a,SElemType theta,SElemType b);//计算部分表达式的值              
ElemType In(char c,char op[]);//判断输入的字符是不是运算符

//初始化栈
int InitStackOptr(SqStackOptr *S) {
    S->base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S->base) {
        exit(OVERFLOW);
    }
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
    return OK;
}

int InitStackOpnd(SqStackOpnd *S) {
    S->base = (ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
    if(!S->base) {
        exit(OVERFLOW);
    }
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
    return OK;
}

//取得栈顶元素
SElemType GetTopOptr(SqStackOptr *S) {
    if(S->top == S->base) {
        return ERROR;
    }
    return *(S->top-1);
}
ElemType GetTopOpnd(SqStackOpnd *S) {
    if(S->top == S->base) {
        return ERROR;
    }
    return *(S->top-1);
}

//入栈
int PushOptr(SqStackOptr *S,SElemType e) {
    if((S->top-S->base)>=S->stacksize) {
        S->base = (SElemType*)realloc(S->base,(S->stacksize+STACKINCREMENT)*sizeof(SElemType));
        if(!S->base) exit(OVERFLOW);
        S->top = S->base + S->stacksize;
        S->stacksize += STACKINCREMENT;
    }
    *S->top++ = e;
    return OK;
}
int PushOpnd(SqStackOpnd *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(OVERFLOW);
        S->top = S->base + S->stacksize;
        S->stacksize += STACKINCREMENT;
    }
    *S->top++ = e;
    return OK;
}

//删除栈中的元素
int PopOptr(SqStackOptr *S,SElemType *e) {
    if(S->top  == S->base) return ERROR;
    *e = *--S->top;
    return OK;
}
int PopOpnd(SqStackOpnd *S,ElemType *e) {
    if(S->top  == S->base) return ERROR;
    *e = *--S->top;
    return OK;
}

//销毁栈
int DestoryStackOptr(SqStackOptr *S) {
    S->top = S->base;
    free(S->base);
    S->top = NULL;
    S->base = NULL;
    return OK;
}
int DestoryStackOpnd(SqStackOpnd *S) {
    S->top = S->base;
    free(S->base);
    S->top = NULL;
    S->base = NULL;
    return OK;
}
//判断输入的字符是不是运算符
ElemType In(char c,char op[]) {
    int i,f=0;
    for(i=0; i<7; i++) {
        if(c == op[i]) {
            f = 1;
            break;
        }
    }
    if(f==0) return 0;
    else return 1;
}
//比较运算符优先级
SElemType Precede(char topc,char c) {
    if (topc=='+'||topc=='-') {
        if(c=='+'||c=='-'||c==')'||c=='#') {
            return '>';
        } else {
            return '<';
        }
    }
    
    if (topc=='*'||topc=='/') {
        if(c=='(') {
            return '<';
        } else {
            return '>';
        }
    }

    if (topc=='(') {
        if(c==')') {
            return '=';
        } else {
            return '<';
        }
    }

    if (topc==')') {
        return ')';
    }

    if (topc=='#') {
        if(c=='#') {
            return '=';
        } else {
            return '<';
        }
    }

}

ElemType Operate(ElemType a,SElemType theta,ElemType b) {
     switch(theta) {
     case '+':
         return a+b;
         break;
     case '-':
         return a-b;
         break;
     case '*':
         return a*b;
         break;
     case '/':
         return a/b;
         break;
     }
 }
//求表达式的值
ElemType EvaluateExpression(SqStackOptr *OPTR,SqStackOpnd *OPND) {
    //算数表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合
    SElemType c,theta,x;
    ElemType a,b;
    SElemType op[7] = {'+','-','*','/','(',')','#'};
    InitStackOptr(OPTR);
    InitStackOpnd(OPND);
    PushOptr(OPTR,'#');
    printf("请输入表达式：");
    c = getchar();
    while(c!='#'|| GetTopOptr(OPTR)!='#') {
        if(!In(c,op)) {
            PushOpnd(OPND,c-'0');
            c = getchar();
        } else {
            switch(Precede(GetTopOptr(OPTR),c)) {
            case '<'://栈顶元素优先级低
                PushOptr(OPTR,c);
                c = getchar();
                break;
            case '>'://栈顶元素优先级高
                PopOptr(OPTR,&theta);                
                PopOpnd(OPND,&b);
                PopOpnd(OPND,&a);
                PushOpnd(OPND,Operate(a,theta,b));
                break;
            case '=':
                PopOptr(OPTR,&x);
                c = getchar();
                break;
            }
        }
    }
    return GetTopOpnd(OPND);
}
int main()
{
    SqStackOpnd OPND;
    SqStackOptr OPTR;
    int result;
    result = EvaluateExpression(&OPTR,&OPND);
    printf("表达式的结果为：%d",result);
    system("pause");
    return 0;
}