栈的应用之表达式求值

#include<stdio.h>
#include <conio.h>
#include<stdlib.h>
#include<iostream.h>
#include <math.h>
#include <ctype.h>
#include<string.h>
typedef int SElemType;
#define OK 1
#define ERROR 0
#define FALSE 0
//#define OVERFLOW 0
typedef int Status;
#define MAXSIZE 100
typedef struct{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{/*构造一个空栈S*/
    S.base=new SElemType[MAXSIZE];
	if(!S.base)  exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=MAXSIZE;
    return OK;
}
Status Push(SqStack &S,SElemType e)
{/*入栈*/
	if(S.top-S.base==S.stacksize)  return ERROR;
	*S.top++=e;
	return OK;
}
Status Pop(SqStack &S,SElemType &e)
{/*删除S的栈顶元素，用e返回其值*/
	if(S.top==S.base)  return ERROR;
	e=*--S.top;
	return OK;
}
SElemType GetTop(SqStack S)
{/*读取栈顶元素*/
	if(S.top!=S.base)
		return *(S.top-1); 
}
Status In(char c)
{//判断c是否是一个运算操作符
	switch(c){
	case '+':
	case '-':
	case '*':
	case '/':
	case '(':
	case ')':
	case '#':
    case '%':
		return true;
		break;
	default:
		return false;
		break;
    }
}
char Precede(char op1,char op2)
{//判断op1和op2优先级的高低，返回'>','<','='
	switch(op1){
	case '+':
		switch(op2){
		case '*':
		case '/':
		case '(':
			return '<';
			break;
		default:
			return '>';
			break;
		}
		break;
		case '-':
			switch(op2){
			case '*':
			case '/':
			case '(':
				return '<';
				break;
			default:
				return '>';
				break;
            }
			break;
			case '*':
            switch(op2){
                case '(':
                       return '<';
                       break;
                default:
                    return '>';
                    break;
            }
            break;
        case '/':
            switch(op2){
                case '(':
                       return '<';
                       break;
                default:
                    return '>';
                    break;
            }
            break;
        case '(':
            switch(op2){
                case ')':
                    return '=';
                    break;
                default:
                    return '<';
                    break;
            }
            break;
        case ')':
            switch(op2){
                default:
                    return '>';
                    break;
            }
            break;
        case '#':
            switch(op2){
                case '#':
                    return '=';
                    break;
                default:
                    return '<';
                    break;
            }
            break;
        default:
            return '<';
            break;
    }
}
int operate(int a,char theta,int b)
{/*对操作数a，b进行theta运算，并返回运算结果
 theta只能是四则运算符号*/
    int rs_i;
    switch(theta){
        case '+':
            rs_i=a+b;
            break;
        case '-':
            rs_i=a-b;
            break;
        case '*':
            rs_i=a*b;
            break;
        case '/':
            if(b==0){
                printf("errror:除数为0.");
                exit(0);
            }
            rs_i=a/b;
            break;
        default:
            printf("Is not a operator.\n");
            break;
    }
    printf("%d %c %d = %d\n",a,theta,b,rs_i);
    return rs_i;

}
const char *getOpnd(const char *c,int *op)
{/*获得以*c开始的操作数，返回后c为操作符*/
    int tmp,sum=0;
    while(FALSE==In(*c))   //当c不是操作符
	{                    
        tmp=*c-'0';
        sum=sum*10+tmp;
        c++;
    }
    *op=sum;
    return c;
}
void Standard(char *expression)
{/*将字符串表达式标准化为算术表达式*/
    char *p=expression,*q;
    while(*p!='\0')            //遍历字符串
	{
        if(*p==' ')
		{                      //如果是空格，删除
            q=p;
            do{
                *q=*(q+1);
                q++;
            }while(*q!='\0');
        }
        p++;
    }
    *p++='#';
    *p='\0';
}
int EvalueateExpression(const char *expression)
{/*对只有四则运算符的算数表达式 expression 求值
 OPTR:操作符栈，OPND:操作数栈*/
    const char *c=expression;
    SqStack OPND;
    SqStack OPTR;
    int x,theta;
    int a,b,num,result;
	InitStack(OPND);             //初始化操作数栈
    InitStack(OPTR);             //初始化操作符栈
    Push(OPTR,'#');              //起始符'#'压入栈
    while(*c!='#'||GetTop(OPTR)!='#')
	{
        if(*c=='\0')             //遇到回车退出
            break;
        if(FALSE==In(*c))
		{
            c=getOpnd(c,&num);
            Push(OPND,num);
        }
        else
            switch(Precede(GetTop(OPTR),*c)){
                case '<':
                    Push(OPTR,*c);
                    c++;
                    break;
                case '=':
                    Pop(OPTR,x);
                    c++;
                    break;
                case '>':
                    Pop(OPTR,theta);
                    Pop(OPND,b);
                    Pop(OPND,a);
                    result=operate(a,theta,b);
                    Push(OPND,result);
                    break;
            }
    }
    return GetTop(OPND);
}
int main()
{   
	char ch;
    int result=0;
    char *expression=(char*)malloc(sizeof(char)*256);
    do{
		if(expression==NULL)
		{
			printf("Sorry,memory initialize error.\n");
			exit(0);
		}
		printf("Please input an expression:\n");
		gets(expression);
		Standard(expression);          //标准化
		result=EvalueateExpression(expression);
		printf("The result of the expression:%d\n",result);
		printf("是否继续？[y/n][y]");
		while((ch=getchar())!='\n');    
	}while((ch=getchar())=='y'||ch=='\n');
}