Question

将后缀转换为中缀的好算法是什么？我搜索和搜索但我只获得从中缀转换为后缀的算法。它们将是相当类似的算法正确吗？我还想加入括号。例如，（（（13-1）/ 2）（3 + 5））。谢谢！

Answer 1

这是后缀版本： -

13 1 - 2 / 3 5 + *

要进行转换，将其解析为普通的后缀解析器，但将元素作为字符串存储在堆栈中，而不是作为值： -

"13"
"1"
"-"

当您获得一个运算符时，如上所述，转换为单个字符串并在其周围加上括号： -

"(13-1)"

继续： -

"(13-1)"
"2"
"/"

变为： -

"((13-1)/2)"

继续： -

"((13-1)/2)"
"3"
"5"
"+"

变为： -

"((13-1)/2)"
"(3+5)"

最后： -

"((13-1)/2)"
"(3+5)"
"*"

最终为： -

"((13-1)/2)*(3+5)"

您可以将“*”视为特殊情况，并在合并版本中省略它。

Answer 2

我们从空堆栈开始。假设后缀表达式是正确的：

读取原子令牌并将它们放在堆栈上
当你到达一个操作员时，从堆栈中弹出n个元素，其中n是操作符的arity，正确格式化，将括号括起来并将分辨率推回堆栈
当没有什么可读的时候，堆栈应该只包含一个带有结果的元素

例如：

输入：2,3,+,5,-,8,*

每个步骤后包含堆栈：

 2
 2,3
 (2+3)
 (2+3),5
 ((2+3)-5)
 ((2+3)-5),8
 (((2+3)-5)*8)

Answer 3

这将是我的方法

while(input.hasNext()) {
   symbol = input.readNextSymbol(); // read the whole token
   if (symbol is operand) {
      stack.push(symbol)
   } else { // the symbol is an operator
      if (stack.count < 2) {
          ERROR too few operands
      } else {
         op2 = stack.pop();
         op1 = stack.pop();
         piece = "("+op1+symbol+op2+")";
         stack.push(piece);
      }      
   }
}

if (stack.count == 1) {
   stack.pop() is the INFIX
} else {
   ERROR
}

当然，如果你想考虑一元运算符，那么条件必须更加结构化以考虑具有单个元素的堆栈

Answer 4

这是所提算法的完整Ruby实现：

#!/usr/bin/env ruby

parts = gets.strip.split(/ +/)

stack = [ ]

parts.each do |part|
  if part =~ /\D/  # it's a binary operation
    right_operand = stack.pop
    left_operand = stack.pop
    stack.push("(#{left_operand} #{part} #{right_operand})")
  else             # it's a number
    stack.push(part)
  end
end

if stack.size == 1
  result = stack[0][1..-2]  # remove outer parentheses
  puts result
  exit(0)
else
  puts "parse error, stack does not contain exactly one element"
  exit(1)
end

像这样使用：

echo '13 1 - 2 / 3 5 + *' | ruby postfix-to-infix.rb

此示例生成结果：

((13 - 1) / 2) * (3 + 5)

从后缀转换为中缀

4 个答案: