栈的基本操作及其应用 表达式求值

输入一个表达式求结果

因为程序的限制数的大小有限制

#include<stdio.h>
#include<iostream> 
#include<cstdio>
#include<stdlib.h>  
#include<string.h>
#include<string>
using namespace std;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -1

typedef char SElemType;
typedef int Status;

typedef struct
{
	SElemType *base;  //栈底指针 
	SElemType *top;   //栈顶指针 
	int stacksize;   //栈可用最大容量 
}SqStack;

//构造一个空栈
Status InitStack (SqStack &S) 
{ 
	S.base = new SElemType[MAXSIZE];   //为顺序栈动态分配一个最大容量为MAXSIZE的数组空间 
	if(!S.base )  exit(OVERFLOW);      //存储分配失败 
	S.top=S.base ;                     // top初始base，空栈 
	S.stacksize = MAXSIZE;             //stacksize置为最大容量MAXSIZE 
	return OK;	
}

//入栈 
Status Push(SqStack &S,SElemType e)
{//插入新的栈顶元素 e 
 	if(S.base - S.top == S.stacksize )  return ERROR;   //栈空 
	*S.top ++ = e;                         //e压入栈列，栈顶指针加1 
	return OK;
} 

//出栈 
Status Pop(SqStack &S,SElemType &e)
{//插入新的栈顶元素 e 
 	if(S.base == S.top )  return ERROR;   //栈空 
	e = *--S.top;                         //栈顶指针减1 ，将栈顶元素赋给e 
	return OK;
}

//取栈顶元素 
SElemType GetTop(SqStack S)
{//插入新的栈顶元素 e  
 	if(S.base != S.top )    //栈非空 
	   return *(S.top - 1);    //返回栈顶元素，栈顶指针不变 
}

//In
int In(char x1)
{
	if( x1 =='(' || x1 ==')' || x1 =='+' || x1 =='-' || x1=='*' || x1=='/' || x1=='#')
	 return OK;
	else 
	 return ERROR;
} 

char Operate(char i, char th,char j)   //运算函数 
{
	char k;
	i = i -'0';
	j = j -'0';
	switch( th )
	{
		case '+':
			k = i+j+'0';
		case '-':
			k = i-j+'0';
		case '*':
			k = i*j+'0';
		case '/':
			k = i/j+'0';
	}
	return k;
}

char Precede( char a,char b)   //比较优先级 
{
	switch( a )   
	{
		case '+':
		  if( b == '+' || b == '-' || b == ')' || b == '#') 
		       return '>';
		  else if(b == '*' || b == '/' || b == '(')	
		       return '<';
		    break;
		 
		case '-':
		  if( b == '+' || b == '-' || b == ')'|| b == '#' ) 
		       return '>';
		  else if( b == '('|| b == '*' || b == '/' )	
		       return '<';
		   break;
		  	
		case '*':
	      if( b == '+' || b == '-' || b == ')'|| b == '#' || b == '*' || b == '/' )
		     return '>';
		  else if( b == '(')	
		     return '<';
		   break;
		  
		case '/':
		  if( b == '+' || b == '-' || b == ')'|| b == '#' || b == '*' || b == '/' )
		     return '>';
		  else if( b == '(')	
		     return '<';
		  break;
		  
		case '(':
		  if( b == ')')
		     return '=';
		  else if( b == '+' || b == '-' || b == '('|| b == '*' || b == '/')
		     return '<';
		  break;
		  
		case ')':
		  if( b == '+' || b == '-' || b == ')'|| b == '#' || b == '/' || b == '*')
		      return '>';	
		   break;
		  
		  
	    case '#':
	      if( b == '#')
	         return '=';
	      else if(b == '+' || b == '-' || b == '('|| b == '#' || b == '/' || b == '*')
		     return '<';
			break;	
	}
	
}

//表达式求值
char EvaluateExpersion()
{//算数表达式求值的算符优先算法，设OPTR和OPND分别为运算符栈和操作符栈 
    SElemType ch;
    SqStack OPTR;
    SqStack OPND;
     char x; 
    
	InitStack(OPTR);   //初始化OPTR栈 
	InitStack(OPND);   //初始化OPND栈 
	
    Push(OPTR,'#');    //将表达式起始符“# ”入OPTR栈 
    cin>>ch;
    
    char theta,a,b;
    
	while( ch!='#' || GetTop(OPTR) != '#' )    //表达式没有扫描完毕或者OPTR的栈顶元素不为“# ” 
	{
		if( !In(ch) )                      //ch不是运算符则进OPND栈 
		{
		  Push(OPND,ch);
		  cin>>ch;
		}
		else
		 switch( Precede( GetTop(OPTR),ch) )     //比较栈顶元素和ch的优先级 
		 {
		 	case '<':
		 		Push(OPTR,ch);                  //将当前字符压入OPTR栈，读入下一字符ch 
		 		cin>>ch;
		 		break;
		    case '>':
		    	Pop(OPTR,theta);               //弹出OPTR栈顶的运算符 
		    	Pop(OPND,b);                   //弹出OPTR栈顶的两个运算数 
		    	Pop(OPND,a);
		 		Push(OPND,Operate(a,theta,b));  //将运算结果压入OPND栈 
		 		break;
		    case '=':               //OPTR栈的栈顶元素是”（  ”且 ch是 “） ” 
		 	    Pop(OPTR , x);            // 弹出OPTR的栈顶的“（ ” ，读入下一字符ch 
		 		cin>>ch;
		 		break;
		 }
	}
	return GetTop(OPND)-'0';          //OPND栈顶元素即表达式求值结果 
} 

int main()
{
	cout<<"表达式结果为："<<EvaluateExpersion()<<endl;
	return 0;
}