表达式求值（只包括小括号）

表达式求值

前缀式：就是将操作符放到数值的前面；如：a+b :  +ab；

中缀式：就是将操作符放在数值中间，其实就是我们平时生活中所写的正常的表达式。如：a+b；

后缀式：就是将操作符放在数值的后面，比如：a+b：——ab+.

对于表达式求值，最简单的当然是对后缀表达式（也称为逆波兰式）进行求值了。

而我们生活中所写的运算表达式，一般都是中缀表达式。但是我们计算的时候用到的却是后缀表达式。这就需要我们首先将中缀表达式转换为后缀表达式，然后再进行运算了。

1、中缀式转换为后缀式

下面是将中缀式（常见运算式）转换为后缀式的算法（该算法只能处理只包含“（”和“）”的运算符）：

栈底放‘#’，从左至右逐字读取中缀式：

   a.当当前字符为数字时，直接输出；
   b.当当前字符为"("时，将其压栈；
   c.当当前字符为")"时，则弹出堆栈中最上的"("之前的所有运算符并输出，然后删除堆栈中的"(" ；
   d.当当前字符为运算符时，则依次弹出堆栈中优先级大于等于当前运算符的(到"("之前为止)，输出，再将当前运算符压栈；
   e.当为"#"时，弹出所有栈中的内容输出

中缀式：a*(b+c)/d+e

后缀式：abc+*d/e+

2、后缀式计算

计算后缀表达式的具体算法如下：

首先定义一个栈stk，用于存放计算结果。

　　a.当前元素为数值，直接入栈；

　　b.如果当前元素是运算符，则将stk中栈顶的两个元素弹出：m，n；

　　c.根据运算符类别（+、-、*、/）计算t = n op m;(m 是第一个弹出栈的元素)；

　　d.将计算的结果t重新压入栈stk中。

　　e.当后缀表达式还未结束，转到a继续执行，否则计算结束。stk此时的栈顶元素即是最后的计算结果。

具体的实现代码如下所示：

#include <iostream>
#include <fstream>
#include <sstream>
#include <stack>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
using namespace std;

map<char,int> priority;

void setPriority()
{
    priority['-'] = 1;
    priority['+'] = 1;
    priority['*'] = 2;
    priority['/'] = 2;
}

void InfixToPostfix(const string &src,vector<char> &exp)
{
    int i,n;
    stack<char> op;

    n = src.size();
    for (i = 0; i < n; i++)
    {
        switch(src[i])
        {
        case '(':
            op.push(src[i]);
            break;
        case ')':
            while (op.size() != 0 && op.top() != '(')
            {
                exp.push_back(op.top());
                op.pop();
            }
            op.pop();
            break;
        case '+':
        case '-':
        case '*':
        case '/':
            while (op.size() != 0 && priority[op.top()] >= priority[src[i]])
            {
                exp.push_back(op.top());
                op.pop();
            }
            
            op.push(src[i]);
            break;
        case ' ':
            break;
        default:
            while (isdigit(src[i]) && i<n)
            {
                exp.push_back(src[i]);
                i++;
            }
            i--;
            exp.push_back('#');
        }
    }
    while (op.size() !=0 )
    {
        exp.push_back(op.top());
        op.pop();
    }
}

void displayExp(vector<char> &src)
{
    int i,n;
    n = src.size();
    for (i = 0; i < n; i++)
    {
        cout<<src[i];
    }
    cout<<endl;
}

void initArray(char a[],int n)
{
    int i;
    for (i = 0; i < n; i++)
    {
        a[i] = '\0';
    }
}

int calculate(int a,int b,char op)
{
    switch (op)
    {
    case '+':
        return a+b;
        break;
    case '-':
        return a-b;
        break;
    case '*':
        return a*b;
        break;
    case '/':
        if (b != 0)
        {
            return a/b;
        }
        else
        {
            return 0;
        }
    default:
        perror("error!\n");
    }
}

int calculatePostfix(const vector<char> &src)
{
    stack<int> stk;
    char str[10];
    int i,n,temp,k;
    int opd1,opd2;
    int result;

    n = src.size();
    
    for (i = 0; i < n; i++)
    {
        switch(src[i])
        {
        case '#':
            break;
        case '+':
        case '-':
        case '*':
        case '/':
            opd2 = stk.top();
            stk.pop();
            opd1 = stk.top();
            stk.pop();
            result = calculate(opd1,opd2,src[i]);
            stk.push(result);
            break;
        default:
            k = 0;
            while ((isdigit(src[i])) && (i < n))
            {
                str[k++] = src[i++];
            }
            temp = atoi(str);
            stk.push(temp);
            initArray(str,10);
            i--;
        }
    }
    return result;
}

int main()
{
    ifstream in("data.txt");
    string src;
    int result;
    vector<char> postfix;
    getline(in,src);
    
    setPriority();
    InfixToPostfix(src,postfix);
    displayExp(postfix);
    result = calculatePostfix(postfix);
    cout<<src<<" = "<<result;
    cout<<endl;
    return 0;
}