Shunting Yard算法C ++

Question

我曾尝试将Dijkstra的Shunting Yard算法作为大学项目的一部分。 一切都按预期工作，但我也需要显示操作符在进程后如何排序，我不知道如何做到这一点，我相信最好的方法是队列？ 有没有人知道如何做到这一点？ 我的代码：

// Finding operators 
int operators(char op){ 
    if(op == '+'||op == '-') 
    return 1; 
    if(op == '*'||op == '/') 
    return 2; 
    return 0; 
} 

// The maths
int maths(int a, int b, char op){ 
    switch(op){ 
        case '+': return a + b; 
        case '-': return a - b; 
        case '*': return a * b; 
        case '/': return a / b; 
    } 
  return 0;
} 

// Returning value of expression
int evaluate(string tokens){ 
    int i; 

    // stack to store integers and operators. 
    stack <int> numbers;  
    stack <char> ops; 

    for(i = 0; i < tokens.length(); i++){ 

        // if token blank, skip 
        if(tokens[i] == ' ') 
            continue; 

        // if token '(' add to stack
        else if(tokens[i] == '('){ 
            ops.push(tokens[i]); 
        } 

        // if token is a number, add to stack
        else if(isdigit(tokens[i])){ 
            int val = 0; 

            // single or double digit number.
            while(i < tokens.length() && 
                        isdigit(tokens[i])) 
            { 
                val = (val*10) + (tokens[i]-'0'); 
                i++; 
            } 

            numbers.push(val); 
        } 

        // if token ')', solve entire brace. 
        else if(tokens[i] == ')') 
        { 
            while(!ops.empty() && ops.top() != '(') 
            { 
                int val2 = numbers.top(); 
                numbers.pop(); 

                int val1 = numbers.top(); 
                numbers.pop(); 

                char op = ops.top(); 
                ops.pop(); 

                numbers.push(maths(val1, val2, op)); 
            } 

            // pop opening brace. 
            ops.pop(); 
        } 

        // Current token is an operator. 
        else
        { 

            while(!ops.empty() && operators(ops.top()) 
                                >= operators(tokens[i])){ 
                int val2 = numbers.top(); 
                numbers.pop(); 

                int val1 = numbers.top(); 
                numbers.pop(); 

                char op = ops.top(); 
                ops.pop(); 

                numbers.push(maths(val1, val2, op)); 
            } 

            // Push current token to 'ops'. 
            ops.push(tokens[i]); 
        } 
    } 

    //Do remaining operations 
    while(!ops.empty()){ 
        int val2 = numbers.top(); 
        numbers.pop(); 

        int val1 = numbers.top(); 
        numbers.pop(); 

        char op = ops.top(); 
        ops.pop(); 

        numbers.push(maths(val1, val2, op)); 
    } 

    // Top of 'numbers' contains result, return
    return numbers.top(); 
} 

int main() { 
    cout << evaluate("10 + 10 * 10") << "\n"; 
    cout << evaluate("3 + 4 * 2 + ( 23 - 5 )") << "\n"; 
    cout << evaluate("100 * ( 2 + 12 )") << "\n"; 
    cout << evaluate("100 * ( 5 + 8 ) / 7") << "\n"; 
    return 0; 
}  

Answer 1

考虑后缀表达式明确显示评估顺序。 例如，中缀表达式a+b*c变为abc*+ ，并且(a+b)*c变为ab+c* 。

如果您遵循代码的表达式评估，您将看到评估的顺序可以由后缀表达式表示。

您可以修改代码以在评估的同时输出后缀表达式。 基本思想是每当你按下一个操作数（一个数字），你也可以将它附加到你的后缀表达式。 每当执行操作时，都会将操作符附加到后缀表达式。 当然，括号永远不会添加到后缀中。

因此，当您评估(a+b)*c ，请执行以下操作：

1. 将'（'推到运算符堆栈上。
2. 将'a'推入操作数堆栈，并在后缀表达式中附加'a'。
3. 将“+”推入运算符堆栈。
4. 将'b'推入操作数堆栈，并将'b'追加到后缀表达式中。
5. 你遇到'）'。 从运算符堆栈弹出'+'并附加到您的后缀表达式。 从操作数堆栈中弹出“a”和“b”，执行操作，并将结果推回到运算符堆栈。
6. 将'*'推送到运算符堆栈。
7. 将“c”按到操作数堆栈，然后附加到后缀表达式。
8. 你在表达的最后。 从运算符堆栈弹出'*'，附加到后缀表达式，弹出操作数和求值。

您应该能够在代码中轻松地进行这些更改。 无论何时调用numbers.push() ，还要将数字附加到后缀表达式。 每当你调用ops.pop()来删除一个运算符（而不是'（'））时，将弹出的运算符追加到你的后缀表达式。当你完成评估后，输出后缀表达式。