字符串表達式求值（支持多種類型運算符）

一、說明

1. 輸入字符串為中綴表達式，無需轉為后綴表達式

2. 支持的運算符包括：

算術運算符："+,-,*,/"

關系運算符：">,<,>=,<=,=,!="(注意等於運算符采用的是一個等號)

邏輯運算符："&&,||"

3. 支持大於10的數字，不支持負數操作數，但支持中間結果和返回值為負數

二、算法原理&步驟

本文算法對中綴表達式形式字符串進行求值，同時支持與或運算和邏輯運算(若含有關系運算符或者邏輯運算符，則輸出為1或者0)。類似於加減乘除，將關系運算符和邏輯運算符看作優先級低的運算符進行處理，優先級：算術運算符>關系運算符>邏輯運算符。

步驟：

1. 初始化兩個空堆棧，一個存放操作數，一個存放運算符。

2. 從左至右掃描輸入字符串，依次讀取。

• 2.1 若為操作數，則壓入操作數棧；
• 2.2 若為運算符，判斷其優先級是否大於運算符棧棧頂元素優先級。若大於棧頂元素優先級，則直接壓棧；否則，彈出棧頂元素operator，同時依次從操作數棧中彈出兩個元素number1,number2，計算表達式(number2 operator number1)的值value，並將值value壓入操作數棧。重復上述過程直至當前掃描的操作符優先級大於棧頂元素，然后將當前運算符壓棧。

3. 彈出運算符棧頂元素operator，同時依次從操作數棧中彈出兩個元素number1,number2，計算表達式(number2 operator number1)的值value，並將值value壓入操作數棧。重復上述過程直至運算符棧為空。

4. 此時操作數棧應該只有一個元素，即為表達式的值。

三、代碼&測試

求值函數：

/* 字符串表達式求值
 * @param input: 輸入的字符串
 * @param output: 表達式的值，若含有關系運算符則為1或者0
 * return 計算過程是否正常
 */
bool ExpValue(string input,int& output)
{
    stack<int> operand_stack;
    stack<string> operator_stack;

    char prev = 0; // 上一個屬於運算符的字符
    for (int i = 0; i < input.size(); i++)
    {
        char c = input[i];
        // prev是否是一個完整運算符
        if (!isOperator(c) && prev)
        {
            string new_op = string("").append(1, prev);
            addNewOperator(new_op, operand_stack, operator_stack);
            prev = 0;
        }

        // 數字
        if (isdigit(c))
        {
            int val_c = c - '0';
            if (i > 0 && isdigit(input[i - 1]))
            {
                int top_num = operand_stack.top();
                top_num = top_num * 10 + val_c;
                operand_stack.pop();
                operand_stack.push(top_num);
            }
            else
                operand_stack.push(val_c);
        }
        // 運算符字符
        else if (isOperator(c))
        {
            // 處理兩字符運算符
            if (prev)
            {
                string new_op = string("").append(1, prev).append(1, c);
                addNewOperator(new_op, operand_stack, operator_stack);
                prev = 0;
            }
            else
                prev = c;
        }
        else if (c == '(')
            operator_stack.push("(");
        else if (c == ')')
        {
            // 處理括號內的運算符
            while (operator_stack.top()!="(")
            {
                int num1 = operand_stack.top();
                operand_stack.pop();
                int num2 = operand_stack.top();
                operand_stack.pop();
                string op = operator_stack.top();
                operator_stack.pop();

                int val = Calculate(num2, num1, op);
                operand_stack.push(val);
            }
            operator_stack.pop(); // 彈出"("
        }
    }
    assert(operand_stack.size() == operator_stack.size() + 1);
    // 彈出所有運算符
    while(!operator_stack.empty())
    {
        int num2 = operand_stack.top();
        operand_stack.pop();
        int num1 = operand_stack.top();
        operand_stack.pop();
        string op = operator_stack.top();
        operator_stack.pop();

        int val = Calculate(num1, num2, op);
        operand_stack.push(val);
    }

    if (operand_stack.size() == 1) {
        output = operand_stack.top();
        return true;
    }
    return false;
}

其中用到的子函數有：

/* 判斷字符是否屬於運算符 */
bool isOperator(char c)
{
    switch (c)
    {
    case '-':
    case '+':
    case '*':
    case '/':
    case '%':
    case '<':
    case '>':
    case '=':
    case '!':
    case '&':
    case '|':
        return true;
    default:
        return false;
    }
}

/* 獲取運算符優先級 */
int getPriority(string op)
{
    int temp = 0;
    if (op == "*" || op == "/" || op == "%")
        temp = 4;
    else if (op == "+" || op == "-")
        temp = 3;
    else if (op == ">" || op == "<" || op == ">=" || op == "<="
        || op == "=" || op == "!=")
        temp = 2;
    else if (op == "&&" || op == "||")
        temp = 1;
    return temp;
}
/* 
 * 返回一個兩元中綴表達式的值
 * syntax: num_front op num_back
 * @param num_front: 前操作數
 * @param num_back: 后操作數
 * @param op: 運算符
 */
int Calculate(int num_front, int num_back, string op)
{
    if (op == "+")
        return num_front + num_back;
    else if (op == "-")
        return num_front - num_back;
    else if (op == "*")
        return num_front * num_back;
    else if (op == "/")
        return num_front / num_back;
    else if (op == "%")
        return num_front % num_back;
    else if (op == "!=")
        return num_front != num_back;
    else if (op == ">=")
        return num_front >= num_back;
    else if (op == "<=")
        return num_front <= num_back;
    else if (op == "=")
        return num_front == num_back;
    else if (op == ">")
        return num_front > num_back;
    else if (op == "<")
        return num_front < num_back;
    else if (op == "&&")
        return num_front && num_back;
    else if (op == "||")
        return num_front || num_back;

    return 0;
}
/* 新運算符入棧操作 */
void addNewOperator(string new_op, stack<int>& operand_stack, stack<string>& operator_stack)
{
    while (!operator_stack.empty() && getPriority(operator_stack.top()) >= getPriority(new_op))
    {
        int num2 = operand_stack.top();
        operand_stack.pop();
        int num1 = operand_stack.top();
        operand_stack.pop();
        string op = operator_stack.top();
        operator_stack.pop();

        int val = Calculate(num1, num2, op);
        operand_stack.push(val);
    }
    operator_stack.push(new_op);
}

 

測試結果：

int main()
{
    string s0 = "10-1*10+3%2";
    string s1 = "100 + (3-33)*2";
    string s2 = "20+1 >= 20 && 20+1 < 20";
    string s3 = "10>20 || 10/1>=5";
    int ret = -1;
    if (ExpValue(s0, ret))
        cout << s0 << "的值: " << ret << endl;

    if (ExpValue(s1, ret))
        cout << s1 << "的值: " << ret << endl;

    if (ExpValue(s2, ret))
        cout << s2 << "的值: " << ret << endl;

    if (ExpValue(s3, ret))
        cout << s3 << "的值: " << ret << endl;
    return 0;
}

上述代碼的執行結果為：

​​​