输入一个算术表达式，以#为结束符，如：(1+2)*3-4/2#，计算其值

输入一个算术表达式，以#为结束符，如：(1+2)*3-4/2#，计算其值
【问题描述】输入一个算术表达式，以#作为结束符，如：(1+2)*3#，计算该表达式的值

【输入形式】(1+2)*3-4/2#

【输出形式】7

【样例输入】(1+2)*3-4/2#

【样例输出】7

【样例说明】样例中只给出了0~9以内的四则运算，测试数据中有10以上的四则运算，如果要使程序完全通过所有测试，则要考虑2位数以上的运算。
【部分代码】

/***顺序实现表达式求值***/

#include<iostream>

#include<stdlib.h>

#include<stdio.h>

using namespace std;



//顺序栈定义

#define OK 1

#define ERROR 0

#define OVERFLOW -2

#define MAXSIZE  100

typedef int Status;

typedef int SElemType;

typedef struct{

SElemType *base;

SElemType *top;

int stacksize;

}SqStack;



//算法3.1　顺序栈的初始化

Status InitStack(SqStack &S)

{// 构造一个空栈 S 

S.base = new SElemType[MAXSIZE];//为顺序栈分配一个最大容量为MAXSIZE的数组空间

if(!S.base)

exit (OVERFLOW);    //存储分配失败

S.top = S.base;

S.stacksize = MAXSIZE;

return OK;

}

//算法3.2　顺序栈的入栈

Status Push(SqStack &S,SElemType e)

{ // 插入元素e为新的栈顶元素

if(S.top-S.base==S.stacksize)

return ERROR;//栈满

*(S.top++) = e;//元素e压入栈顶，栈顶指针加1

return OK;

}

//算法3.3　顺序栈的出栈

Status Pop(SqStack &S,SElemType &e)

{// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR

if(S.base == S.top)

return ERROR;//栈空

e = *(--S.top); //栈顶指针减1，将栈顶元素赋给e

return OK;

}

//算法3.4　取顺序栈的栈顶元素

SElemType GetTop(SqStack S)

{// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR

if(S.top == S.base)

return ERROR;

return *(S.top-1);//栈顶指针减1，将栈顶元素赋给e

}



Status In(SElemType c)// 应在前面有定义typedef char SElemType;

{ // 判断c是否为运算符
  switch(c)
  {
  	case'+':return true;
  	case'-':return true;
  	case'*':return true;
  	case'/':return true;
  	case'(':return true;
  	case')':return true;
  	case'#':return true;
   	default:return false;
  }

}



SElemType Precede(SElemType t1,SElemType t2)

 { //根据教材表3.1，判断两个运算符的优先关系

   SElemType f=' ';
   switch(t1)
   {
    case '+': 
   	    if(t2=='+'||t2=='-'||t2=='#'||t2==')')
   	    f='>';
   	else 
     	f='<';
    break;
    case '-':
   	    if(t2=='+'||t2=='-'||t2=='#'||t2==')')
   	    f='>';
   	else 
     	f='<';
    break;
    case '*':
   	    if(t2=='+'||t2=='-'||t2=='*'||t2=='/'||t2=='#'||t2==')')
   	    f='>';
   	else 
     	f='<';
    break;
    case '/':
   	    if(t2=='+'||t2=='-'||t2=='*'||t2=='/'||t2=='#'||t2==')')
   	    f='>';
   	else 
     	f='<';
    break;
    case '#':
   	    if(t2=='+'||t2=='-'||t2=='*'||t2=='/'||t2=='(')
   	    f='<';
   	else 
     	f='=';
    break;
    case '(':
   	    if(t2=='+'||t2=='-'||t2=='*'||t2=='/'||t2=='#'||t2=='(')
   	    f='<';
   	else 
     	f='=';
    break;
    case ')':
   	    if(t2=='+'||t2=='-'||t2=='*'||t2=='/'||t2==')'||t2=='#')
   	    f='>';
   	else 
     	f='<';
    break;
   }
   return f;

}



SElemType Operate(SElemType a,SElemType theta,SElemType b)

{

   SElemType c=0;
   switch(theta)
   {
   	case'+':
   		c=a+b;
   		break;
   	case'-':
   		c=a-b;
   		break;
	case'*':
   		c=a*b;
   		break;	
	case'/':
   		c=a/b;
   		break;	      	
   }
   return c;

}



//算法3.22　表达式求值

char EvaluateExpression()

{

// 算术表达式求值的算符优先算法。设OPTR和OPND分别为运算符栈和操作数栈，

// OP 为运算符集合

SqStack OPTR,OPND;
InitStack(OPTR); 
InitStack(OPND);
Push(OPTR,'#');
int ch,theta,a,b,x;
ch=getchar();
char *str=new char[10];
int k=0,num=0;
bool flag=false;
while(ch != '#' || (GetTop(OPTR)!='#') )

{

  if (!In(ch))

   {
     str[k++]=ch;
     ch=getchar();
     flag=false;
   } // ch不是运算符则进栈

else
 {
	if(!flag)
	{
		str[k]='\0';
		num=atoi(str);
		Push(OPND,num);
		k=0;
		flag=true;
	}

    switch(Precede(GetTop(OPTR),ch))

   { //比较OPTR的栈顶元素和ch的优先权
    case '<': //当前字符ch压入OPTR栈，读入下一字符ch
    Push(OPTR, ch);
    ch = getchar();
    break;

    case '>': //弹出OPTR栈顶的运算符进行相应运算，并将运算结果入栈
    Pop(OPTR,theta);
    Pop(OPND, b);
    Pop(OPND, a);
    Push(OPND, Operate(a, theta, b));

    break;

    case '=': //脱括号并接收下一字符

    Pop(OPTR, x);

    ch = getchar();

    break;

    } // switch
 }
}// while
cout<<(int)GetTop(OPND)<<endl;
return GetTop(OPND);

// EvaluateExpression
}


int main()

{

//cout<<"请输入要计算的表达式（操作数和结果都在0-9的范围内，以#结束）："<<endl;

EvaluateExpression();

return 0;

}