四则（栈or二叉树）

法一：用栈将中缀转后缀

(1).首先从string读入表达式，取出每一个字符后装入queue容器coll1中。

(2).从该容器取出每一个元素，利用栈将中缀表达式转换成后缀表达式，将后缀表达式装入容器coll3中。

(3).最后从coll3中取出元素逐一处理，既使用逆波兰式求值（如下图）。

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

首先，将中缀转换为后缀

目的：

将中缀表达式（即标准形式的表达式）转换为后缀式。

例子：a+b*c+(d*e+f)*g转换成abc*+de*f+g*+

 

转换原则：

1.当读到一个操作数时，立即将它放到输出中。操作符则不立即输出，放入栈中。遇到左圆括号也推入栈中。

2.如果遇到一个右括号，那么就将栈元素弹出，直到遇到一个对应的左括号停止。但是这个左括号只被弹出，并不输出。

3.在读到操作符c时，如果此时栈顶操作符优先性>=此操作符c，弹出栈顶操作符直到c优先级<栈顶，并将c入栈。除了处理')'的时候，否则决不从栈中移走'('。操作符中，'+' '-'优先级最低，'(' ')'优先级最高。

4.如果读到输入的末尾，将栈元素弹出直到该栈变成空栈，将符号写到输出中。

 

解如下：

首先，读入'a'，并送到输出，然后'+'被读入并压入栈中。接下来b读入并送到输出，此时状态如下：

栈: +                                   

输出：a b

接下来读入'*'，由于优先性比栈顶元素'+'大（原则3），因此被压入栈顶，接着读入'c'，并送到输出：

栈: + *                                 

输出：a b c

        

然后读入'+'，由于此时栈顶元素为'*'，优先级比'+'大，因此将'*'弹出，弹出后原来的'+'变成栈顶元素，由于'+'的优先性和当前读入的'+'优先性相等，因此也被弹出（原则3），最后将读入的'+'压入栈中。因此此时状态如下：

栈: +                                   

输出：a b c * +

     

下一个读入的符号是'('，由于具有最高优先级，因此将其放入栈中，然后读入'd':

栈: + (                                 

输出：a b c * + d

           

继续读入，此时读入'*'，除非处理')'，否则'('决不弹出（原则3），因此'*'被压入栈中，接下来读入'e',并送到输出：

栈: + ( *                               

输出：a b c * + d e

             

再往后读入的符号是'+'，将'*'弹出并输出。（原则3，与之前步骤相似），然后将'+'压入栈中，接着读入'f'并送到输出：

栈:    + ( +                            

输出：a b c * + d e * f

           

现在读入')'，因此弹出栈元素直到遇到'('（原则2）：

栈:    +                              

输出： a b c * + d e * f +

          

下面又读入一个'*'，被压入栈中，然后读入'g'并输出：

栈:    + *                                

输出： a b c * + d e * f + g

          

现在输入为空，弹出栈中所有元素：

栈:    空                                  

输出： a b c * + d e * f + g * +          

#include <iostream>

#include <queue>
#include <stack>
#include <string>
using namespace std;
class Cal{
public:
int getpriority(char c)
{
switch (c)
{
case '+':
case '-':
return 0;
break;
case '*':
case '/':
return 1;
break;
case '(':
case ')':
return -1;
break;
}
}
int ispra(char c)
{
if (c == '(' || c == ')')
return 1;
else
return 0;
}
void check(char c,stack<char>& col2,queue<char>& col3)
{
if (col2.empty())
{
col2.push(c);
return;
}
//是否为括号
if (ispra(c))
{
if (c == '(')
col2.push(c);
else
{
while (col2.top()!='(')
{
char ch = col2.top();
col3.push(ch);
col2.pop();
}
col2.pop();
}
}
else //不是括号
{
char TopOpt = col2.top();
if (getpriority(c) <= getpriority(TopOpt))
{
col3.push(TopOpt);
col2.pop();
check(c, col2, col3);
}
else
{
col2.push(c);
}
}
}


void allocate(queue<char>& col1,stack<char>& col2,queue<char>& col3)
{
while (!col1.empty())
{
char c = col1.front();
col1.pop();
//数字直接入栈
if (c >= '0'&&c <= '9')
{
col3.push(c);
}
//否则根据运算符优先级
else
{
check(c,col2,col3);
}
}


while (!col2.empty())
{
char opt = col2.top();
col2.pop();
col3.push(opt);
}


}
int calculate(queue<char>& col3, stack<int>& col4)
{
while (!col3.empty())
{
char c = col3.front();
col3.pop();
if (c >= '0'&&c <= '9')
{
int value = c - '0';
col4.push(value);
}
else
{
int value1 = col4.top();
col4.pop();
int value2 = col4.top();
col4.pop();
switch (c)
{
case '+':
col4.push(value2+value1);
break;
case '-':
col4.push(value2-value1);
break;
case '*':
col4.push(value2*value1);
break;
case '/':
col4.push(value2/value1);
break;
}
}
}
return col4.top();
}
};


int main()
{
queue<char> col1;//中缀
stack<char> col2;//操作符
queue<char> col3;//后缀
stack<int> col4;//计算辅助,存数据
string str;
cin >> str;
for (int i = 0; i != str.size();++i)
{
col1.push(str[i]);
}
Cal cal;
cal.allocate(col1,col2,col3);
cout<<cal.calculate(col3,col4)<<endl;

}

法二：用二叉树将中缀转后缀