利用栈的原理计算一个表达式的值

#include<stdio.h>
#include <stdio.h>   
#include <malloc.h>   
#include <ctype.h>   
#define TRUE        1   
#define FALSE       0   
#define OK          1   
#define ERROR       0   
#define INFEASIBLE -1   
#define OVERFLOW    -2   
#define STACK_INIT_SIZE  100   
#define STACKINCREMENT   10   
typedef int  Status;  
/*计算整数表达式的值 
 *表达式必须以#结束 
 *表达式中可以出现多位数字， 
 *表达式中可以出现空格 
 *运算符包括+,-,*,/,(,) 
 *运算结果可以是多位整数，并以整数的形式返回 
 */ 
typedef int SElemType;/*放入堆栈的元素的类型*/  


/*判断输入的某个字符是否是运算符 
 *c表示输入的字符 
 *op数组中存放系统能识别的运算符 
 */  
Status in(char c,char op[]){  
    char *p; //指针，用于指向op数组 
    p=op;  //将op数组的地址给p,数组中的数组名一般表示数组的头地址，只要知道了头地址那么就可以访问数组了。
    while(*p != '\0'){  //当
        if(c == *p)  
            return TRUE;  
        p++;  
    }  
    return FALSE;  
}  
/*比较两个运算符的优先级 
 *a，b中存放待比较的运算符 
 *'>'表示a>b 
 *'0'表示不可能出现的比较 
 */  
char Precede(char a, char b){  
    int i,j;  
    char pre[][7]={           
    /*运算符之间的优先级制作成一张表格*/  
        {'>','>','<','<','<','>','>'},  
        {'>','>','<','<','<','>','>'},  
        {'>','>','>','>','<','>','>'},  
        {'>','>','>','>','<','>','>'},  
        {'<','<','<','<','<','=','0'},  
        {'>','>','>','>','0','>','>'},  
        {'<','<','<','<','<','0','='}};  
    switch(a){  
        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(b){  
        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 pre[i][j];  
}  
/*进行实际的运算 
 *a，b中分别以整数的形式存放两个待运算的操作数 
 *thea中存放代表操作符的字符 
 *结果以整数的形式返回 
 */                  
int Operate(int a, char thea, int b){  
    int i,j,result;  
    i=a;  //a，b中分别以整数的形式存放两个待运算的操作数 
    j=b;  
                
    switch(thea)   {  
        case '+': result = i + j; break;  //加法运算
        case '-': result = i - j; break;  //减法运算
        case '*': result = i * j; break;  //乘法运算
        case '/': result = i / j; break;  //除法运算               
    }  
    return result;  
}  
/*从输入缓冲区中获得下一个整数或运算符，并通过n带回到主调函数 
 *返回值为1表示获得的是运算符 
 *返回值为0表示获得的是整形操作数 
 */  
int getNext(int *n){  
    char c;  
    *n=0;  
    while((c=getchar())==' ');  /*跳过一个或多个空格*/  
    if(!isdigit(c)){            /*通过函数判断如果字符不是数字，那么只能是运算符*/  
        *n=c;  
        return 1;  
    }  
    do    {                         /*能执行到该条语句，说明字符是数字，此处用循环获得连续的数字*/  
        *n=*n*10+(c-'0');       /*把连续的数字字符转换成相对应的整数*/  
        c=getchar();  
    }    while(isdigit(c));         /*如果下一个字符是数字，进入下一轮循环*/  
    ungetc(c,stdin);            /*新读入的字符不是数字，可能是运算符,为了不影响下次读入，把该字符放回到输入缓冲区*/  
    return 0;  
}  


typedef struct{  
    SElemType *base;  
    SElemType *top;  
  int    stacksize;  
}SqStack;  
//构造一个空栈   
Status InitStack(SqStack *S){  
    S->base = (SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));  
  
    if(!S->base)  
       printf("OVERFLOW");// exit(OVERFLOW);  
    S->top=S->base;  
    S->stacksize=STACK_INIT_SIZE;  
    return OK;  
}  
//判断是否为空栈   
Status StackEmpty(SqStack S){  
    if(S.top == S.base)  
        return TRUE;  
    else  
        return FALSE;  
}  
//用e返回S的顶元素   
Status GetTop(SqStack S, SElemType *e){  
    if(S.top == S.base)  
        return ERROR;  
    *e = *(S.top-1);  
    return OK;  
}  
//插入e为新的顶元素   
Status Push(SqStack *S, SElemType e){  
    if((S->top - S->base) >= S->stacksize){  
        S->base = (  
                    SElemType*)realloc(S->base,  
                   (S->stacksize+STACKINCREMENT)*sizeof(SElemType)  
                   );  
        if(!S->base)  
           return ERROR;// exit(OVERFLOW);  
        S->top = S->base +S->stacksize;  
        S->stacksize += STACKINCREMENT;  
    }  
    *(S->top)=e;  
    S->top++;  
    return OK;  
}  
//删除S的顶元素，并用e返回其值   
Status Pop(SqStack *S, SElemType *e){  
    if(S->top == S->base)  
        return ERROR;  
    S->top--;  
    *e = *(S->top);  
    return OK;  
}  
//从栈底到栈顶依次对S的每个元素调用函数Visit（），一旦失败操作无效   
Status ListTraverse(SqStack S,Status (*visit)(SElemType)){  
    SElemType *p;  
    p=S.base;  
    for(p=S.base;p<S.top;p++)  
        (*visit)(*p);  
  
    return OK;  
}  
//输出元素e   
Status output(SElemType e){  
    printf("%d ",e);  
  
    return OK;  
}  
  
int EvaluateExpression()//操作函数
{  
  
   // int n;  
    int flag;  //0,1标志
    int c;  
    SElemType x,thea;  
    int a,b;  
  
char OP[]="+-*/()#";  
    SqStack  OPTR;  
    SqStack  OPND;  
  
    InitStack(&OPTR);//构造空栈        
Push(&OPTR,'#');  //元素入栈
    InitStack(&OPND);  
    flag=getNext(&c);//调用getNext函数  
  
    GetTop(OPTR,&x); //调用GetTop函数，获得栈顶元素值给x 
    while(c!='#' || x != '#')  //当c不是结束标志并且x也不是结束标识时
    {  
        if(flag == 0)  
         {  
                  Push(&OPND,c);  //调用Push函数，新元素入栈
                  flag = getNext(&c); //调用getNext函数   
             }        else  
    {  
            GetTop(OPTR, &x);  //调用GetTop函数，获得栈顶元素值给x 
            switch(Precede(x,c))  
        {  
                case '<'://栈顶元素优先级低                       
                    Push(&OPTR,c);  
                    flag = getNext(&c);  
                    break;  
                case '='://脱括号并接受下一字符    
                    Pop(&OPTR,&x);  
                    flag = getNext(&c);  
                    break;  
case '>':// 退栈并将运算结果入栈                                          
                    Pop(&OPTR, &thea);  
                    Pop(&OPND,&b);  
                    Pop(&OPND,&a);  
                    Push(&OPND, Operate(a, thea, b));  
                    break;  
            }  
        }  
        GetTop(OPTR, &x);  
    }  
    GetTop(OPND, &c);  
    return c;  //返回值c
}  


  
void main(){  
    int c;  
    printf("请输入您想输入的符号或数字:");  
    c=EvaluateExpression();  //调用EvaluateExpression函数
    printf("计算结果=%d\n",c); //输出c
fflush(stdin);//以下这两个函数是为了解决程序有时闪屏而用的
getchar();


}