[算法 笔记]字符串表达式计算（简易版）

　　题目：编写一个函数，计算字符串中表达式的值，参数中只包含计算符：+，-，*，/等。例如，str=”10+50+2*6/3”，result=64。

　　解析：

　　考虑算术表达式计算规则：

1.  同优先级操作符之间，从左到右计算；
2. 高优先级操作符的计算要早于低优先级操作符的计算；
3. 加减操作符优先级低于乘除操作符优先级；
4. 括号内的算术表达式的优先级高于括号外的乘除操作符的优先级。

　　利用两个辅助栈来存储结果。一个用于存储数值，一个用于存储操作符。考虑算术表达式的计算过程（从左往右计算，先计算高优先级操作符），因此表达式字符串逆序压入栈中。由于考虑栈存储的特点以及计算表达式的顺序问题，需要逆序的将数值和算术符压入到栈中。因此，需要首先将数值逆序，然后在将整个表达式逆序。

　　考虑操作符优先级的处理问题：在计算过程将出现三种情况（用current_opr表示刚刚从栈中弹出的操作符，top_opr表示操作符栈中栈顶的操作符）：

1. current_opr的优先级等于top_opr的优先级；
2. current_opr的优先级大于top_opr的优先级；
3. current_opr的优先级小于top_opr的优先级。

　　在上述三种情况中，第一种和第二种均情况不需要考虑，直接计算直到current_opr的优先级低于top_opr的优先级。

　　现在来讨论第三种情况的处理过程，将current_opr从栈顶开始向栈底“冒泡”，一直到操作符的优先级等于current_opr才停止。在操作符移动的过程中，数值栈中的元素也需要进行同方向的“冒泡”处理，但是深度要比操作符多一个。因为目前考虑的操作符均是二元操作符，需要两个操作数来完成计算。

　　例如，算式字符串为：”25 + 10*50*12”。遍历的结果为：

　　数值栈：（digit_stack，value_top=3）

12

50

10

25

　　操作符栈：（op_stack，opr_top=1）

‘*’

‘*’

　　处理过程：由于current_opr = ‘+’，top_opr=’*’，priority(current_opr) < priority(top_opr)，因此需要对current_opr操作符进行“冒泡”处理，一直到优先级与current_opr相同为止。

　　调整后，数值栈：（digit_stack，value_top=3）

25

12

50

10

　　调整后，操作符栈为：（op_stack，opr_top=1）

‘+’

‘*’

　　当前，current_opr=’*’，top_opr=’*’，则priority(current_opr) == priority(top_opr)，即符号第一种情况。

　　在编程中，对于“冒泡”处理有两种形式：

　　1. 首先将元素压入栈中，然后通过交换的形式来达到“冒泡”处理。

for ( i = opr_top - 1; i > 0; --i )
{
    if ( priority(op_stack[i]) < priority(op_stack[i-1]) )
        swap( op_stack, i, i - 1 );
    else
        break;
} 

for ( j = value_top - 1; j > i; --j )
{
    swap( value_stack, j, j - 1 );
}

　　2. 不将数值压入栈中，而是首先查找符合要求的“位置”，然后将元素插入。

for ( i = opr_top; i > 0; --i )
{
    if ( priority(op_stack[j-1]) > priority(current_opr) )
        op_stack[j] = op_stack[j-1];
    else
        break;
}
op_stack[i] = current_opr;
++opr_top;

for ( j = value_top; j > i; --j )
{
    value_stack[j] = value_stack[j - 1];
}
value_stack[j] = result;
++value_top;

　　完整程序的源码：

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <stdexcept>
using namespace std;

class stack_is_empty : public runtime_error
{
public:
    stack_is_empty( const string s )
    : runtime_error( s ){}
};

class divisor_is_zero: public runtime_error
{
public:
    divisor_is_zero( const string s )
    : runtime_error( s ) {}
};


/**< expression reversal */
void expression_reversal( string &expr )
{
    string::iterator iter = expr.begin();
    string::iterator tmp;

    while ( iter != expr.end() )
    {
        if ( *iter >= '0' && *iter <= '9' )
        {
            /**< value reversal */
            for ( tmp = iter; iter != expr.end()
                   && *iter >= '0' && *iter <= '9'; ++iter );
            reverse( tmp, iter );
        }
        else
            ++iter;
    }

    /**< expression reversal */
    reverse( expr.begin(), expr.end() );
}

/**< remove spaces of expression */
void remove_space( string &orig_expr, string &expr )
{
    string::iterator iter = orig_expr.begin();

    for ( ; iter != orig_expr.end() ; ++iter )
    {
        if ( *iter != ' ' )
            expr.push_back( *iter );
    }
}

/**< separation of value and operators. */
void preprocess( string &orig_expr,
                vector<int> &value_stack,
                vector<char> &oper_stack )
{
    string expr;
    remove_space( orig_expr, expr );
    expression_reversal( expr );

    string::iterator iter = expr.begin();

    while ( iter != expr.end() )
    {
        // push value into value_stack.
        if ( *iter >= '0' && *iter <= '9' )
        {
            int value = 0;
            while ( iter != expr.end()
                   && *iter >= '0' && *iter <= '9' )
            {
                value *= 10;
                value += ( *iter - '0' );
                ++iter;
            }

            value_stack.push_back( value );
        }
        else
        {
            // push operator into oper_stack.
            oper_stack.push_back( *iter );
            ++iter;
        }
    }
}

/**< get priority of operator */
int oper_priority( const char ch )
{
    int flag = 0;
    if ( ch == '*' || ch == '/' )
        flag = 5;

    return flag;
}

/**< compute value with operator */
int compute_value( int lhs, int rhs, char oper )
{
    int value = 0;
    switch( oper )
    {
    case '+': value = lhs + rhs; break;
    case '-': value = lhs - rhs; break;
    case '*': value = lhs * rhs; break;
    case '/':
        if ( rhs == 0 )
            throw divisor_is_zero( "divisor is zero." );
        value = lhs / rhs;
        break;
    default: break;
    }

    return value;
}

/**< compute value  */
int compute_expr( vector<int> &value, vector<char> &oper )
{
    char current_oper = '';
    int current_value = 0;

    if ( value.empty() || oper.empty() )
    {
        throw stack_is_empty( "Stack is empty." );
        return -1;
    }

    while ( value.empty() == false
           && oper.empty() == false )
    {
        current_oper = oper.back(), oper.pop_back();

        if ( oper.empty()
            || oper_priority( current_oper ) >= oper_priority( oper.back() )  )
        {
            int lhs = value.back();
            value.pop_back();
            int rhs = value.back();
            value.pop_back();
            current_value = compute_value( lhs, rhs, current_oper );
            value.push_back( current_value );
        }
        else
        {
            /**< value and operators are moved to new place. */
            oper.push_back( current_oper );
            size_t last_index = oper.size() - 1;
            for ( ; last_index > 0; --last_index  )
            {
                if ( oper_priority( oper[last_index - 1] )
                     <= oper_priority( current_oper ) )
                    break;
                oper[last_index] = oper[last_index - 1];
            }
            oper[last_index] = current_oper;

            current_value = value.back();
            for ( size_t j = value.size() - 1;
                    j > last_index; --j )
            {
                value[j] = value[j - 1];
            }
            value[last_index] = current_value;
        }
    }

    if ( oper.empty() )
    {
        current_value = value.front();
    }

    return current_value;
}

int main()
{
    string str( " 50 - 20 + 5 * 6 / 2" );
    vector<int> value;
    vector<char> oper;
    int result = 0;
    preprocess( str, value, oper );

    result = compute_expr( value, oper );
    cout << result << endl;

    return 0;
}

　　简易版本不足之处：

1. 不能计算括号表达式
2. 对负数不能有效的处理
3. 不能有效计算大数
4. 对表达式中符号以及括号的合法性检查