中缀表达式求解

问题描述：

      中缀表达式计算，只包含加减乘除以及括号，例如：

      2+3*4-5/2 = 11.5

      ((2+3*4)-5)/2 = 4.5

 

思路：

　　1. 维护两个栈空间：数字栈与符号栈

　　2. 注意入栈与出栈的规则，符号栈入栈时，根据符号优先级判断是否入栈或出栈。

          高优先级符号后入栈时直接放入即可，低优先级符号后入栈时先弹出高优先级符号，优先级如下：

          ( < +- < * / < )

　　　 普通操作符弹出计算时，只进行一次pop_cal操作。

　　　 右括号出栈时，必须循环计算至左括号出栈为止。

 

边界case：

　　1. 分母为0，assert处理。

　　2. 数字范围超出变量上下限。

 

知识点：

　　1. 栈操作：围绕出栈入栈操作分解问题，分解成cal计算函数、push_xxx压栈操作、pop_cal出栈计算操作、push_check入栈检查优先级等几步，逻辑会更清晰。

　　2. 字符处理：用stringstream简化处理逻辑，string -> float, float -> string，多次使用之间需要clear() & str("")，重置标识以及清空字符串两个操作。

 

难度：★★★★

　　1. 代码量大

　　2. 需要考虑的细节多：字符处理、边界case、符号优先级、右括号特殊处理

　　3. 熟悉栈操作

　　

 伪码：

#include <stack>
#include <string>
#include <sstream>
#include <iostream>
#include <assert.h>
#include <ctype.h>

using namespace std;

stack<string> nums; //数字栈
stack<char> exps;   //操作符栈

//压入数字栈
void push_num(char exp, bool is_new)
{
    if( is_new )
    {
        string new_num = string("") + exp;
        nums.push( new_num );
    }
    else
    {
        string top_num = nums.top();
        nums.pop();
        top_num += exp;
        nums.push( top_num );
    }
}

//得到优先级
int get_priority(char exp)
{
    switch( exp )
    {
        case '*':
            return 2;
        case '/':
            return 2;
        case '+':
            return 1;
        case '-':
            return 1;
        case '(':
            return 0;
        case ')':
            return -1;
    }
    return 0;
}

//检查入栈优先级
bool push_check(char exp)
{
    if( exps.size() == 0 )
    {
        return true;
    }
    int cur_prio = get_priority(exp);
    int top_prio = 3;
    char top_exp = exps.top();
    top_prio = get_priority(top_exp);
    if( cur_prio < top_prio )
    {
        return false;
    }
    return true;
}

//数字出栈
void pop_nums(float &num1, float &num2)
{
    stringstream ss;
    string num = nums.top();
    ss << num;
    ss >> num1;
    nums.pop();
    ss.clear();
    ss.str("");
    num = nums.top();
    ss << num;
    ss >> num2;
    nums.pop();
}

//出栈一次并计算结果，返回当前出栈操作符
char pop_cal(float &res)
{
    res = 0.0;
    char exp = exps.top();
    exps.pop();
    if( exp != '(' )
    {
        float num1, num2;
        pop_nums(num1, num2);
        switch( exp )
        {
            case '*':
                res = num2 * num1;
                break;
            case '/':
                res = num2 / num1;
                break;
            case '+':
                res = num2 + num1;
                break;
            case '-':
                res = num2 - num1;
                break;
        }
    }
    return exp;
}

//压入操作符栈
void push_exp(char exp)
{
    while( ! push_check(exp) )
    {
        float res;
        char pop_exp = pop_cal(res);
        if( pop_exp != '(' )
        {
            string num;
            stringstream ss;
            ss << res;
            ss >> num;
            nums.push( num );
        }
        if( exp == ')' && pop_exp == '(' )
            break;
    }
    if( exp != ')' )
    {
        exps.push( exp );
    }
}

//主函数：计算中缀表达式
float cal_res(const string &express)
{
    //是否新数字
    bool new_num = true;
    //循环读取表达式字符
    for(size_t i = 0; i < express.size(); i++)      
    {
        //处理数字
        if( isdigit( express[i] ) || express[i] == '.' )
        {
            //数字压栈
            push_num(express[i], new_num);
            new_num = false;
        }
        else
        {
            //操作符压栈
            push_exp( express[i] );
            new_num = true;
        }
    }
    //循环出栈，计算结果
    float res = 0.0;
    while( exps.size() > 0 )
    {
        pop_cal( res );
    }
    return res;
}

int main()
{
    string expression = "(3.2+4.0/2.1)*5.0";
    cout << cal_res( expression ) << endl;
    return 0;
}

 

转载请注明引用自：

　　http://www.cnblogs.com/breakthings/p/4049575.html