栈的应用之表达式求值（算符优先法）

为了简化问题，我们只考虑+、-、*、/四种运算，他们的优先级规则：

(1)先乘除，后加减

(2)从左算到右

(3)先括号内，再括号外



为了实现算符优先算法，需要两个工作栈，一个用来存放操作数（CZS），一个用来存放运算符（YSF）。

算法的基本思想：

（1）首先置操作数栈、运算符栈均为空，将‘#’压入运算符栈。

（2）依次读入表达式中的每个字符，如果是操作数则直接压入操作数栈（当然，操作数可能不是一位数，可以先用字符串保存每次读入的字符，再转为Int型，压入操作数栈）。如果是运算符，则需要与运算符栈顶元素比较。若运算符栈顶字符的优先级高于当前预算符，出现句柄，需要从操作数栈中弹出两个操作数，从运算符栈顶弹出一个运算符，进行运算后将结果压入操作数栈，注意，此时并没有读入下一个字符，还是用当前字符和栈顶字符比较；若运算符栈顶字符优先级小于当前字符，则直接将当前字符压入运算符栈，读入下一个字符；若运算符栈顶字符的优先级等于当前字符，如’(‘和’)’，则运算符栈弹出一个元素，读入下一个字符。

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

# define MAX 100

//运算符
typedef struct{
char data[MAX];
int top;
}Operator;

//操作数
typedef struct{
int data[MAX];
int top;
}Operand;

int operate(int a,char theta,int b);
void InitStack(Operator &s);
void InitStack(Operand &s);
int Push(Operator &s,char c);
int Push(Operand &s,int a);
int Pop(Operator &s);
int Pop(Operand &s);
char getTop(Operator &s);
int getTop(Operand &s);
char Precede(char a,char b);

int main()
{
Operator YSF;//运算符栈
Operand CZS;//操作数栈
char num[15];
InitStack(CZS);
InitStack(YSF);
Push(YSF,'#');
printf("-------四则运算（加减乘除）,输入以#号结束--------\n");
char ch=getchar();
while(ch!='#'||getTop(YSF)!='#')
{
int i=0,a,b,flag=0;
char theta;
while(ch>='0'&&ch<='9')
{
flag=1;
num[i++]=ch;
ch=getchar();
}
if(flag)
{
num[i]='\0';
Push(CZS,atoi(num));
}
if(ch<'0'||ch>'9')
{
switch(Precede(getTop(YSF),ch))
{
case '>':
theta=getTop(YSF);
Pop(YSF);
b=getTop(CZS);
Pop(CZS);
a=getTop(CZS);
Pop(CZS);
Push(CZS,operate(a,theta,b));
break;
case '=':
Pop(YSF);
ch=getchar();
break;
case '<':
Push(YSF,ch);
ch=getchar();
break;
}
}
}
printf("%d\n",getTop(CZS));
return 0;
}

int operate(int a,char theta,int b)
{
if(theta=='+')
return a+b;
else if(theta=='-')
return a-b;
else if(theta=='*')
return a*b;
else if(theta=='/')
return a/b;
}

void InitStack(Operator &s)
{
memset(s.data,0,MAX*sizeof(char));
s.top=0;
}

void InitStack(Operand &s)
{
memset(s.data,0,MAX*sizeof(int));
s.top=0;
}

int Push(Operator &s,char c)
{
if(s.top>=MAX)
return 0;
else
{
s.data[s.top]=c;
s.top++;
return 1;
}
}

int Push(Operand &s,int a)
{
if(s.top>=MAX)
return 0;
else
{
s.data[s.top]=a;
s.top++;
return 1;
}
}

int Pop(Operator &s)
{
if(s.top==0)
return 0;
else
{
s.top--;
s.data[s.top]=0;
return 1;
}
}

int Pop(Operand &s)
{
if(s.top==0)
return 0;
else
{
s.top--;
s.data[s.top]=0;
return 1;
}
}

char getTop(Operator &s)
{
return s.data[s.top-1];
}

int getTop(Operand &s)
{
return s.data[s.top-1];
}

//比较两个运算符的优先级，a运算符在b左边
char Precede(char a,char b)
{
if(a=='+'||a=='-')
{
if(b=='+'||b=='-'||b==')'||b=='#')
return '>';
else
return '<';
}
else if(a=='*'||a=='/')
{
if(b=='(')
return '<';
else
return '>';
}
else if(a=='(')
{
if(b=='+'||b=='-'||b=='*'||b=='/'||b=='(')
return '<';
else if(b==')')
return '=';
else
{
printf("输入有误");
return 0;
}
}
else if(a==')')
{
if(b=='+'||b=='-'||b=='*'||b=='/'||b==')'||b=='#')
return '>';
else if(b=='(')
{
printf("输入有误");
return 0;
}
}
else if(a=='#')
{
if(b==')')
{
printf("输入有误");
return 0;
}
else if(b=='#')
return '=';
else
return '<';
}
}