最近补习数据结构(谁叫我不是科班出身呢),看了栈的应用之一,做算术表达式解析计算,但那个例子中没有把括号的逻辑加进去,苦想一段时间后还是没有结果,于是Google出一些表达式解析的方案,觉得用后缀表达式解析是最方便的,遂用Ruby实现了一个,支持由数字、加减乘除和括号组成的表达式,因为主要目的是对栈的应用,所以一些地方能简则简。
class MyParser
PRECEDENCE = [
['(', ')'],
['|'],
['&'],
['+', '-'],
['*', '/']
]
REG_VARIABLE = /\d+(?:\.\d+)?/
REG_OPERATOR = /[\+\-\*\/\|\&]/
REG_PARENTHESIS = /[\(\)]/
REG_SPACE = /\s+/
def self.exec(exp)
exec_postfix parse_to_postfix(exp)
end
# 将表达式解析成后缀表达式,这里后缀表达式改用数组
def self.parse_to_postfix(exp)
postfix_exp, stack = [], []
# 每次从exp中取出第一段标志符(数字,操作符,括号),进行分析,exp中的标志符取完后退出循环
until exp.nil? or exp.size == 0
case exp
when /^(#{REG_VARIABLE})/ # 数字
token = $1
postfix_exp << token
when /^(#{REG_OPERATOR})/ # 操作符
token = $1
# 这个if和else可以合在一起的,但我觉得这样逻辑更清晰,脑袋笨了冒得法啊
if stack.empty?
stack << token
else
# 原来这里的逻辑错了,现已改正
# 当读取的操作符优先级不高于栈中的操作符优先级时,需要依次将栈中的操作符弹出送到表达式中
while stack.size > 0 && precedence(token) <= precedence(stack.last)
postfix_exp << stack.pop
end
stack << token
end
when /^(#{REG_PARENTHESIS})/ # 括号
token = $1
case token
when '('
stack << token
when ')'
postfix_exp << stack.pop while !stack.empty? && stack.last != '('
# 因为一般')'都会有匹配的'(',正常情况下这里stack的最后一个元素一定是'('
raise "mismatched parenthesis '#{token}'" if stack.last != '('
stack.pop
else
raise "parenthesis '#{token}' wrong"
end
when /^(#{REG_SPACE})/ # 空格,这个只是额外处理,和表达式转换的核心逻辑无关
token = $1
else
raise "unknown token! expression is '#{exp}'"
end
exp = exp[token.size..-1]
end
until stack.empty?
# 检查括号是否匹配的,因为stack中只会压入'(',不会压入')'
# 如果表达式括号匹配的话,到这里stack中所有的'('应该都已经被处理了
raise "mismatched parenthesis '('" if stack.last == '('
postfix_exp << stack.pop
end
postfix_exp
end
# 根据后缀表达式计算结果
def self.exec_postfix(postfix_exp)
stack = []
postfix_exp.each do |token|
case token
when REG_VARIABLE # 变量直接压入stack
stack << token.to_f
when REG_OPERATOR # 碰到操作符,从stack中弹出两个数,进行计算,再将结果压入
raise 'stack size < 2'if stack.size < 2
d2, d1 = stack.pop, stack.pop
stack << exec_exp(d1, token, d2)
end
end
raise 'final stack size must be 1' if stack.size != 1
stack.first
end
# 计算操作符的优先级,返回一个数字,数字越大优先级越高
def self.precedence(op)
re = PRECEDENCE.index { |group| group.include?(op) }
raise "unknown operator '#{op}'" if re.nil?
re
end
# 输入两个数和二元运算符,进行计算,返回结果
# 例:exec_exp(1, '+', 2) => 3
def self.exec_exp(d1, op, d2)
case op
when REG_OPERATOR
d1.send(op, d2)
else
raise "operator '#{op}' wrong"
end
end
end
# 测试一下,看算的对不对
puts 'TEST CALCULATE'
[
['1+2*3', 7.0], # 前面是表达式,后面是期望的计算结果,下同
['1*2-3', -1.0],
['10-(4-2)*3', 4.0],
['2*(24-(3*10))+11', -1.0]
].each do |exp, result|
puts exp
postfix_exp = MyParser.parse_to_postfix(exp)
puts " #{'parse'.ljust(9)} = #{postfix_exp}"
puts " #{'calc'.ljust(9)} = #{MyParser.exec_postfix postfix_exp}"
puts " #{'expect'.ljust(9)} = #{result}"
end
# 测试后缀表达式是否正确
puts 'TEST POSTFIX EXPRESSION'
[
['1|2&3+4|5', '1234+&|5|'],
['1-2|3*4&5', '12-34*5&|'],
['(1|2)&3+(4|5)', '12|345|+&']
].each do |exp, result|
puts exp
postfix_exp = MyParser.parse_to_postfix(exp).join
puts " #{'parse'.ljust(9)} = #{postfix_exp}"
puts " #{'expect'.ljust(9)} = #{result}"
end
运行 结果如下:
1+2*3 parse = ["1", "2", "3", "*", "+"] calc = 7.0 expect = 7.0 1*2-3 parse = ["1", "2", "*", "3", "-"] calc = -1.0 expect = -1.0 10-(4-2)*3 parse = ["10", "4", "2", "-", "3", "*", "-"] calc = 4.0 expect = 4.0 2*(24-(3*10))+11 parse = ["2", "24", "3", "10", "*", "-", "*", "11", "+"] calc = -1.0 expect = -1.0
嗯,至少没算错……
下面说说大概思路:
基本逻辑就是两步,先把输入的表达式(我们一般的表达式写法都是中缀表达式)转换成后缀表达式,然后用后缀表达式进行计算。比如这样:
# 中缀表达式,我们通常写的形式 1*2+3 # 这是后缀表达式的写法,基本上是把运算符放到数字后面, # 读法为从前往后读,碰到运算符,就把运算符前的两个数字代入计算,计算结果就取代了原来的两个数字和运算符,以此类推 12*3+ # 再看个复杂点的,中缀表达式如下 1+2*3 # 后缀表达式, 123*+ # 这个是有括号的中缀表达式 (1+2)*3 # 换成后缀表达式就是这样,可以看出,后缀表达式是没有括号和运算符优先级的,比较方便由计算机处理 这正是要转换成后缀表达式的原因 12+3*
后缀表达式很容易被计算机处理,逻辑也不复杂。
其实数据结构教程里的示例代码的原理和上面的Ruby代码十分类似,只是一个直接计算,一个是转换成后缀表达式。
个人感觉数据结构的示例,把对栈的操作和数据计算混在一起,比较乱。而且要处理括号的逻辑,可能要采用递归才能实现,比较麻烦。
参考资料
这篇文章是思路来源,我用Ruby重新实现了一把,补充一些细节,里面讲表达式转换逻辑和后缀表达式计算逻辑比较详细
这篇是我原来比较倾向的思路,完全采用递归,将表达式不停拆分解析,直到最基本的元素,可惜代码太长,比较复杂,懒得看了
这是RednaxelaFX 童鞋补充的资料,Wikipedia上表达式转换的文章,感叹一句:砖业人士啊