带有中括号的中缀转后缀

中缀表达式是人们常用的表达式表示方法，例如：(3 + 4) * 5 - 6，它的运算符位于两个操作数中间。但是，在计算机中，更常见的是后缀表达式，即运算符位于操作数的后面，例如：3 4 + 5 * 6 -，这种表达式也被称为逆波兰表达式。

将中缀表达式转换为后缀表达式的过程被称为中缀转后缀。中缀转后缀可以使用栈来实现。具体步骤如下：

1. 创建一个空栈以存储运算符和左括号。
2. 从左到右扫描中缀表达式。
3. 如果扫描到操作数，则直接将其输出。
4. 如果扫描到运算符，则将其压入栈中，但在压入之前需要先将栈中优先级大于或等于该运算符的所有运算符弹出，并将这些运算符输出。
5. 如果扫描到左括号，则将其压入栈中。
6. 如果扫描到右括号，则将栈中左括号之后的所有运算符弹出，并将这些运算符输出，但左括号不输出。
7. 当扫描完整个中缀表达式后，将栈中的所有运算符弹出并输出。

下面是一个简单的 C++ 实现示例：

#include <iostream>
#include <stack>
#include <string>

using namespace std;

// 判断是否为运算符
bool isOperator(char c) {
    return (c == '+' || c == '-' || c == '*' || c == '/');
}

// 判断运算符优先级
int getPriority(char c) {
    if (c == '+' || c == '-') {
        return 1;
    } else if (c == '*' || c == '/') {
        return 2;
    } else {
        return 0;
    }
}

// 中缀转后缀
string infixToPostfix(string infix) {
    stack<char> s;  // 运算符栈
    string postfix;  // 后缀表达式

    for (int i = 0; i < infix.length(); i++) {
        char c = infix[i];

        // 如果是操作数，直接输出
        if (isdigit(c)) {
            postfix += c;
        } else if (isOperator(c)) {  // 如果是运算符
            // 弹出优先级大于等于该运算符的所有运算符
            while (!s.empty() && getPriority(s.top()) >= getPriority(c)) {
                postfix += s.top();
                s.pop();
            }
            // 将该运算符压入栈中
            s.push(c);
        } else if (c == '(') {  // 如果是左括号
            s.push(c);
        } else if (c == ')') {  // 如果是右括号
            // 弹出左括号之后的所有运算符
            while (!s.empty() && s.top() != '(') {
                postfix += s.top();
                s.pop();
            }
            // 弹出左括号
            if (!s.empty() && s.top() == '(') {
                s.pop();
            }
        }
    }

    // 将栈中剩余的运算符弹出并输出
    while (!s.empty()) {
        postfix += s.top();
        s.pop();
    }

    return postfix;
}

int main() {
    string infix = "2+3*4-(5+6)*7";  // 中缀表达式
    string postfix = infixToPostfix(infix);  // 后缀表达式
    cout << postfix << endl;  // 输出后缀表达式

    return 0;
}

该程序输出的结果为：`234*+56+7*-`。