[数据结构] 表达式求值（转化为后缀表达式再求值或直接求值）

两种情况：

1. 根据输入的算数表达式，如（56-20) /(4+2)， 先转化为后缀表达式（逆波兰式）56#20#-4#2#+/  因为输入的数字有多位数的（56）,所以数之间用#隔开，然后根据后缀表达式求值。

2.根据输入的算数表达式，直接进行求值。

对于情况1：

转化为后缀表达式时用到了一个符号栈，把后缀表达式存放到数组postExp中，根据后缀表达式求值时用到了一个运算数栈，运算完后，栈顶即为所求。

完整代码如下：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;

const int maxOp = 7;//符号的总数

struct Pri //设定运算符优先级
{
char ch; //运算符
int pri; //优先级
}lpri[] = {{'=', 0}, {'(', 1}, {'*', 5}, {'/', 5}, {'+', 3}, {'-', 3}, {')', 6}},
rpri[] = {{'=', 0}, {'(', 6}, {'*', 4}, {'/', 4}, {'+', 2}, {'-', 2}, {')', 1}};

int LeftPri(char op)//求左运算符op的优先级
{
for(int i = 0; i < maxOp; ++ i)
if(lpri[i].ch == op)
return lpri[i].pri;
}

int RightPri(char op)//求右运算符op的优先级
{
for(int i = 0; i < maxOp; ++ i)
if(rpri[i].ch == op)
return rpri[i].pri;
}

bool IsOp(char ch)//判断符号ch是否为运算符
{
if(ch == '(' || ch == ')' || ch == '+' || ch == '-' || ch == '*' || ch == '/')
return true;
return false;
}

int Precede(char op1, char op2) //op1和op2运算符优先级的比较结果
{
int lPri = LeftPri(op1);
int rPri = RightPri(op2);
if(lPri == rPri)
return 0;
else if(lPri < rPri)
return -1;
else
return 1;
}

void TransToPostExp(char* exp, char postExp[]) //将算数表达式exp转换成后缀表达式
{
stack<char>opStack;//运算符栈
opStack.push('=');// =入栈，其优先级最低
int i = 0;//后缀表达式字符指针
while(*exp != '\0')
{
if(!IsOp(*exp)) //如果不是运算符
{
while(*exp >= '0' && *exp <= '9')//是数字
{
postExp[i ++] = *exp;
exp ++;
}
postExp[i ++] = '#'; //用'#'表示一个数值串的结束，比如456#
}
else
{
int cmpPri = Precede(opStack.top(), *exp);
if(cmpPri == 0) //左右运算符优先级相等，也就是()这种情况
{
opStack.pop();// '('退栈
exp ++;
}
else if(cmpPri == -1) //栈顶运算符优先级低
{
opStack.push(*exp);//入栈,符号栈栈顶始终是优先级最高的
exp ++;
}
else //栈顶运算符优先级高
{
while(Precede(opStack.top(), *exp) == 1)//不断退栈
{
postExp[i ++] = opStack.top();
opStack.pop();
}
//opStack.push(*exp);
// exp ++; 一定要注意！不能这样写，因为有可能当前字符是')'
}
}
}
while(opStack.top() != '=')//exp扫描完毕，退栈到' = '为止
{
postExp[i ++] = opStack.top();
opStack.pop();
}
postExp[i] = '\0';//postExp表达式添加结束标识
}

void GetTwoFromStack(stack<double>& numStack, double& a, double& b)//从运算数栈中获取两个数，栈顶和次栈顶
{
a = numStack.top();
numStack.pop();
b = numStack.top();
numStack.pop();
}

float CalFromPostExp(char* postExp)//计算后缀表达式的值
{
stack<double> numStack;//运算数栈
double a, b;
while(*postExp != '\0')
{
switch(*postExp)
{
case '#':
break;
case '+':
GetTwoFromStack(numStack, a, b);//获取运算数栈的两个数
numStack.push(b + a);//进行运算，再压入运算数中
break;
case '-':
GetTwoFromStack(numStack, a, b);
numStack.push(b - a);
break;
case '*':
GetTwoFromStack(numStack, a, b);
numStack.push(b * a);
break;
case '/':
GetTwoFromStack(numStack, a, b);
if(a != 0)
numStack.push(b / a);
else
{
cout << "除0错误! " <<endl;
exit(0);
}
break;
default: //处理数字字符
int n = 0;
while(*postExp >= '0' && *postExp <= '9')
{
n = n * 10 + (*postExp - '0');
postExp ++;
}
numStack.push(n);
break;
}
postExp ++; //继续处理字符
}
return numStack.top();
}

char exp[50];
char postExp[50];

int main()
{
while(cin >> exp)
{
cout << "中缀表达式为: " << exp <<endl;
TransToPostExp(exp, postExp);//将算数表达式转化为后缀表达式,比如输入(56-20)/(4+2) ,输出 56#20#-4#2#+/
cout << "后缀表达式为: " << postExp <<endl;
cout << "表达式的值为: " <<CalFromPostExp(postExp) << endl << endl;
}
return 0;
}

及其容易出现错误的地方为void TransToPostExp(char* exp, char postExp[]) //将算数表达式exp转换成后缀表达式   这个函数中：
else //栈顶运算符优先级高
{
while(Precede(opStack.top(), *exp) == 1)//不断退栈
{
postExp[i ++] = opStack.top();
opStack.pop();
}
//opStack.push(*exp);
// exp ++; 一定要注意！不能这样写，因为有可能当前字符是')'
}

一定要注意如果当前字符时')'时，它的右优先级是最低的，因为除了'('外的其它符号 + - * / 遇到它都得退出符号栈
不要把')'加入到符号栈中，opStack.push(*exp)；

也不要直接忽略')'而继续扫描下一个字符，因为此时栈顶可能时'('，需要进行下一轮的比较，把'('出栈， 所以不能写 exp ++.

也就是说 这里需要特别考虑 当前字符是 ')'的情况

对于情况2：

用到了两个栈，符号栈和运算数栈，对输入的运算数表达式边扫描边求值。

完整代码（来来回回改了N多遍,  支持 ((((3+2))))这种情况) :

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;

const int maxOp = 7;//符号的总数

struct Pri //设定运算符优先级
{
char ch; //运算符
int pri; //优先级
}lpri[] = {{'=', 0}, {'(', 1}, {'*', 5}, {'/', 5}, {'+', 3}, {'-', 3}, {')', 6}},
rpri[] = {{'=', 0}, {'(', 6}, {'*', 4}, {'/', 4}, {'+', 2}, {'-', 2}, {')', 1}};

int LeftPri(char op)//求左运算符op的优先级
{
for(int i = 0; i < maxOp; ++ i)
if(lpri[i].ch == op)
return lpri[i].pri;
}

int RightPri(char op)//求右运算符op的优先级
{
for(int i = 0; i < maxOp; ++ i)
if(rpri[i].ch == op)
return rpri[i].pri;
}

bool IsOp(char ch)//判断符号ch是否为运算符
{
if(ch == '(' || ch == ')' || ch == '+' || ch == '-' || ch == '*' || ch == '/')
return true;
return false;
}

int Precede(char op1, char op2) //op1和op2运算符优先级的比较结果
{
int lPri = LeftPri(op1);
int rPri = RightPri(op2);
if(lPri == rPri)
return 0;
else if(lPri < rPri)
return -1;
else
return 1;
}

void GetTwoFromStack(stack<double>& numStack, double& a, double& b)//从运算数栈中获取两个数，栈顶和次栈顶
{
a = numStack.top();
numStack.pop();
b = numStack.top();
numStack.pop();
}

double CalFromNumStack(stack<char>& opStack, stack<double>& numStack)
//从符号栈提取栈顶符号，利用运算数栈的栈顶和次栈顶进行计算，并把结果压入运算数栈中
{
    double a, b;
    char op = opStack.top();//运算符提取
    opStack.pop();//退栈
    GetTwoFromStack(numStack, a, b);//a,b为栈顶和次栈顶
    switch(op)
    {
    case '+':
        numStack.push(b + a);
        break;
    case '-':
        numStack.push(b - a);
        break;
    case '*':
        numStack.push(b * a);
        break;
    case '/':
        numStack.push((b / a));
        break;
    }//switch
}

float CalFromExp(char* exp)
{
stack<char> opStack;//符号栈
opStack.push('=');//'='优先级最低
stack<double> numStack;//运算数栈
while(*exp != '\0')
{
if(!IsOp(*exp)) //如果不是运算符
{
int n = 0;//提取数字
while(*exp >= '0' && *exp <= '9')
{
n = n * 10 + (*exp - '0');
exp ++;
}
numStack.push(n);//把提取出来的数压入运算数栈
}
else
{
int cmpPri = Precede(opStack.top(), *exp);
if(cmpPri == 0) // ')'遇到栈顶'('
{
opStack.pop();
exp ++;
}

else if(cmpPri == -1)// 栈顶运算符优先级小
{
opStack.push(*exp);
exp ++;
}
else //栈顶运算符优先级大
{
while(Precede(opStack.top(), *exp) == 1)
{
CalFromNumStack(opStack,numStack);
}//while
}
// exp ++;//扫描下一个字符
}//当前字符是运算符
}

while(opStack.top() != '=')//千万不能忘了这个！！
{
CalFromNumStack(opStack,numStack);
}
return numStack.top();
}
char exp[50];
char postExp[50];

int main()
{
while(cin >> exp)
{
cout << "中缀表达式为: " << exp <<endl;
//TransToPostExp(exp, postExp);//将算数表达式转化为后缀表达式,比如输入(56-20)/(4+2) ,输出 56#20#-4#2#+/
// cout << "后缀表达式为: " << postExp <<endl;
cout << "表达式的值为: " <<CalFromExp(exp) << endl << endl;
}
return 0;
}

及其容易出现错误的地方和情况1一样。