表达式求值

http://www.cnblogs.com/flyingbread/archive/2007/02/03/638932.html

分析用堆栈解析算术表达式的基本方法。给出的示例代码能解析任何包括+，-，*，/，()和0到9数字组成的算术表达式。

中缀表达式就是通常所说的算术表达式，比如(1+2)*3-4。
后缀表达式是指通过解析后，运算符在运算数之后的表达式，比如上式解析成后缀表达式就是12+3*4-。这种表达式可以直接利用栈来求解。

中缀表达式翻译成后缀表达式的方法如下：

（1）从左向右依次取得数据ch。

（2）如果ch是操作数，直接输出。

（3）如果ch是运算符（含左右括号），则：
      a：如果ch = '('，放入堆栈。
      b：如果ch = ')'，依次输出堆栈中的运算符，直到遇到'('为止。
      c：如果ch不是')'或者'('，那么就和堆栈顶点位置的运算符top做优先级比较。
          1：如果ch优先级比top高，那么将ch放入堆栈。
          2：如果ch优先级低于或者等于top，那么输出top，反复进行，直到ch优先级高于top或者栈为空，然后将ch放入堆栈。

（4）如果表达式已经读取完成，而堆栈中还有运算符时，依次由顶端输出。

如果我们有表达式(A-B)*C+D-E/F，要翻译成后缀表达式，并且把后缀表达式存储在一个名叫output的字符串中，可以用下面的步骤。

（1）读取'('，压入堆栈，output为空
（2）读取A，是运算数，直接输出到output字符串，output = A
（3）读取'-'，此时栈里面只有一个'('，因此将'-'压入栈，output = A
（4）读取B，是运算数，直接输出到output字符串，output = AB
（5）读取')'，这时候依次输出栈里面的运算符'-'，然后就是'('，直接弹出，output = AB-
（6）读取'*'，是运算符，由于此时栈为空，因此直接压入栈，output = AB-
（7）读取C，是运算数，直接输出到output字符串，output = AB-C
（8）读取'+'，是运算符，它的优先级比'*'低，那么弹出'*'，压入'+"，output = AB-C*
（9）读取D，是运算数，直接输出到output字符串，output = AB-C*D
（10）读取'-'，是运算符，和'+'的优先级一样，因此弹出'+'，然后压入'-'，output = AB-C*D+
（11）读取E，是运算数，直接输出到output字符串，output = AB-C*D+E
（12）读取'/'，是运算符，比'-'的优先级高，因此压入栈，output = AB-C*D+E
（13）读取F，是运算数，直接输出到output字符串，output = AB-C*D+EF
（14）原始字符串已经读取完毕，将栈里面剩余的运算符依次弹出，output = AB-C*D+EF/-

计算算术表达式

当有了后缀表达式以后，运算表达式的值就非常容易了。可以按照下面的流程来计算。

（1）从左向右扫描表达式，一个取出一个数据data
（2）如果data是操作数，就压入堆栈
（3）如果data是操作符，就从堆栈中弹出此操作符需要用到的数据的个数，进行运算，然后把结果压入堆栈
（4）如果数据处理完毕，堆栈中最后剩余的数据就是最终结果。

比如我们要处理一个后缀表达式1234+*+65/-，那么具体的步骤如下。

（1）首先1，2，3，4都是操作数，将它们都压入堆栈
（2）取得'+'，为运算符，弹出数据3，4，得到结果7，然后将7压入堆栈
（3）取得'*'，为运算符，弹出数据7，2，得到数据14，然后将14压入堆栈
（4）取得'+'，为运算符，弹出数据14，1，得到结果15，然后将15压入堆栈
（5）6，5都是数据，都压入堆栈
（6）取得'/'，为运算符，弹出数据6，5，得到结果1.2，然后将1.2压入堆栈
（7）取得'-'，为运算符，弹出数据15，1.2，得到数据13.8，这就是最后的运算结果

 

class ComputeExpr
{
public:
    string transPosExpr(string s);        //将中缀表达式转化成后缀表达式，比如(1+2)*3-4转化成12+3*4-
    double calcExpr(string s);            //计算后缀表达式的值
private:
    int getPriority(char ch);            //获取操作符的优先级
    bool isOperator(char ch);            //判断是否为操作符或者操作数
    double calc(double a,char ch, double b);
};

string ComputeExpr::transPosExpr(std::string s)
{
    string ret;
    stack<char> stkOper;
    int len = s.length();
    for (int i=0; i<len; i++)
    {
        if (!isOperator(s[i]))    //如果是操作数，直接输出
        {
            ret += s[i];
        }
        else if (s[i]=='(')        //如果是'('，将它放入堆栈中
        {
            stkOper.push('(');
        }
        else if (s[i]==')')        //如果是')'
        {
            while(!stkOper.empty())        //不停地弹出堆栈中的内容，直到遇到'('
            {
                char topChar = stkOper.top();
                stkOper.pop();
                if (topChar=='(')
                {
                    break;
                }
                ret += topChar;        //将堆栈中弹出的内容放入
            }
        }
        else        //既不是'('，也不是')'，是其它操作符，比如+, -, *, /之类的
        {        
            if (!stkOper.empty())
            {
                do 
                {
                    char topChar = stkOper.top();
                    stkOper.pop();
                    if (getPriority(s[i]) > getPriority(topChar))//如果栈顶元素的优先级小于读取到的操作符
                    {
                        stkOper.push(topChar);    //将栈顶元素放回堆栈
                        stkOper.push(s[i]);        //将读取到的操作符放回堆栈
                        break;
                    }
                    else        //如果栈顶元素的优先级比较高或者两者相等时
                    {
                        ret += topChar;
                        if (stkOper.empty())
                        {
                            stkOper.push(s[i]);    //将读取到的操作符压入堆栈中
                            break;
                        }
                    }
                } 
                while (!stkOper.empty());
            }
            else         //如果堆栈为空，就把操作符放入堆栈中
            {
                stkOper.push(s[i]);
            }
        }
    }
    while(!stkOper.empty())        //将堆栈中剩下的操作符输出
    {
        ret += stkOper.top();
        stkOper.pop();
    }
    return ret;
}

double ComputeExpr::calcExpr(std::string s)
{
    int len = s.length();
    stack<double> stk;
    for (int i=0; i<len; i++)
    {
        if (!isOperator(s[i]))    //如果是操作数，直接压入栈
        {
            stk.push(s[i]-'0');
        }
        else     //如果是操作符，就弹出两个数字来进行运算
        {
            double a = stk.top();
            stk.pop();
            double b = stk.top();
            stk.pop();
            double t = calc(b,s[i],a);
            stk.push(t);
        }
    }
    return stk.top();
}

int ComputeExpr::getPriority(char ch)
{
    int priority = 0;
    switch(ch)
    {
    case '+':
        priority = 1;
        break;
    case '-':
        priority = 1;
        break;
    case '*':
        priority = 2;
        break;
    case '/':
        priority = 2;
        break;
    default:
        priority = 0;
        break;
    }
    return priority;
}

bool ComputeExpr::isOperator(char ch)
{
    const int MaxOperatorNum = 6;
    const char a[MaxOperatorNum] = {'+','-','*','/','(',')'};
    for (int i=0; i<MaxOperatorNum; i++)
    {
        if (ch == a[i])
        {
            return true;
        }
    }
    return false;
}    

double ComputeExpr::calc(double a,char ch, double b)
{
    double res;
    switch(ch)
    {
    case '+':
        res = a+b;
        break;
    case '-':
        res = a-b;
        break;
    case '*':
        res = a*b;
        break;
    case '/':
        res = a/b;
        break;
    }
    return res;
}