算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。日常使用的算术表达式是采用中缀表示法，即二元运算符位于两个运算数中间。请设计程序将中缀表达式转换为后缀表达式。 输入格式: 输入在一行中给出不含空格的中缀表达式，可包含+、-、*、\以及左右括号()，表达式不超过20个字符。 输出格式: 在一行中输出转换后的后缀表达式，要求不同对象（运算数、运算符号）之间以空格分隔，但结尾不得有多余空格。

### 回答1：
算术表达式有前缀表达式表示法、中缀表达式表示法和后缀表示法等形式。日常使用的算术表达式是采用中缀表达式表示法，即二元运算符位于两个运算数的中间。请设计程序将中缀表达式转换为后缀表达式。输入格式: 输入在一行中给出不含空格的中缀表达式，可包含+、-、*、\等运算符以及左右括号()，表达式不超过20个字符。输出格式: 在一行中输出转换后的后缀表达式，要求不同对象（运算数、运算符号）之间以空格分隔，不能有多余空格。

### 回答2：
中缀表达式转后缀表达式，可以用栈来实现。具体步骤如下：

1. 遍历中缀表达式中的每个字符，如果是数字，直接输出；如果是运算符、括号，就进行如下处理：

2. 如果是左括号，直接入栈；

3. 如果是右括号，就将栈中左括号之后的所有符号依次输出，直到遇到左括号，并且左括号也要出栈；

4. 如果是运算符，就将当前运算符与栈顶运算符比较，如果栈顶优先级高于或者等于当前运算符，就将栈顶运算符出栈，并输出，直到栈顶优先级低于当前运算符或者栈空为止，然后将当前运算符入栈；

5. 遍历完中缀表达式后，将栈中所有符号依次出栈，输出。

下面是具体的Python实现代码：

class Stack:
    def __init__(self):
        self.stack = []
    def push(self, item):
        self.stack.append(item)
    def pop(self):
        if not self.is_empty():
            return self.stack.pop()
    def is_empty(self):
        return len(self.stack) == 0
    def peek(self):
        if not self.is_empty():
            return self.stack[-1]
    def __len__(self):
        return len(self.stack)

def infix_to_postfix(expression):
    precedence = {'+':1, '-':1, '*':2, '/':2}
    stack = Stack()
    postfix = []
    for char in expression:
        if char.isdigit():
            postfix.append(char)
        elif char == '(':
            stack.push(char)
        elif char == ')':
            top = stack.pop()
            while top != '(':
                postfix.append(top)
                top = stack.pop()
        else:
            while (not stack.is_empty()) and (precedence.get(stack.peek(), 0) >= precedence.get(char, 0)):
                postfix.append(stack.pop())
            stack.push(char)
    while not stack.is_empty():
        postfix.append(stack.pop())
    return ' '.join(postfix)

expression = input()
postfix_expression = infix_to_postfix(expression)
print(postfix_expression)

该程序接受一个中缀表达式作为输入，然后输出转换后的后缀表达式。运算符的优先级用一个字典来表示，方便进行比较。程序中使用了一个栈来维护中间状态。先将所有数字直接输出到后缀表达式，遇到括号和运算符时，则根据上述规则进行处理。最后，将栈中所有元素弹出同时输出，就得到了转换后的后缀表达式。

### 回答3：
中缀表达式转换为后缀表达式可以使用栈来实现。栈是一种具有后进先出（LIFO）特性的数据结构。具体实现可以使用一个运算符栈和一个结果栈。

算法流程：

1.从左至右读取中缀表达式。

2.遇到操作数时，直接加入结果栈。

3.遇到运算符时，判断运算符优先级。

a.如果运算符栈为空或栈顶为左括号，直接加入运算符栈。

b.如果运算符优先级高于栈顶运算符，直接加入运算符栈。

c.如果运算符优先级低于或等于栈顶运算符，将栈顶运算符弹出并加入结果栈，再次比较当前运算符与新的栈顶运算符。

d.如果遇到左括号，直接加入运算符栈。

e.如果遇到右括号，将运算符栈中左括号上面的运算符依次弹出并加入结果栈，直到遇到左括号为止，左右括号弹出，但不加入结果栈。

4.遍历完中缀表达式后，将运算符栈中的所有运算符依次弹出并加入结果栈。

5.输出结果栈中的元素，以空格分隔，得到后缀表达式。

Python代码实现：

# 定义运算符优先级
priority = {'+': 1, '-': 1, '*': 2, '/': 2}

# 定义转换函数
def infix2postfix(s):
    op_stack = [] # 运算符栈
    result_stack = [] # 结果栈
    for c in s:
        if c.isdigit(): # 如果是数字，直接加入结果栈
            result_stack.append(c)
        else: # 如果是运算符
            if not op_stack or c == '(': # 如果运算符栈为空或栈顶是左括号，直接加入运算符栈
                op_stack.append(c)
            elif c == ')': # 如果是右括号，弹出运算符栈中左括号上面的所有运算符到结果栈中
                while op_stack[-1] != '(':
                    result_stack.append(op_stack.pop())
                op_stack.pop() # 左括号弹出，不加入结果栈
            elif priority[c] > priority[op_stack[-1]]: # 如果优先级高于栈顶运算符，直接加入运算符栈
                op_stack.append(c)
            else: # 如果优先级低于或等于栈顶运算符
                while op_stack and op_stack[-1] != '(': # 弹出并加入结果栈
                    result_stack.append(op_stack.pop())
                op_stack.append(c) # 当前运算符加入运算符栈
    while op_stack: # 遍历完中缀表达式后，将剩余运算符弹出并加入结果栈
        result_stack.append(op_stack.pop())
    return ' '.join(result_stack) # 返回转换后的后缀表达式

# 测试
print(infix2postfix('1+2*3-(4+5)/6')) # 输出：1 2 3 * + 4 5 + 6 / -

参考资料：

[1] Data Structures and Algorithms in Python

[2] 中缀表达式转后缀表达式（逆波兰式） python3版