$简单算术表达式求值

Refer：http://interactivepython.org/runestone/static/pythonds/BasicDS/InfixPrefixandPostfixExpressions.html

本文主要探讨简单的数学算术表达式求值算法的原理和实现。

1. 约束

本文只是探讨简单的算术表达式的求值算法，为了将主要精力放在算法思想的探讨和实现上，避免陷入对其他不是直接相关的细节的过多思考，所以提前做如下约束：

• 本文所讨论的算术表达式字符串中每个运算数、运算符之间都有空白符分隔开（方便后面用python字符串的split函数分割处理成列表）。

• 算术表达式中参与运算的运算数都为1位整数。

• 表达式中的运算符都为二元运算符（即一个运算符需要两个运算数），不会出现其他元的运算符（如一元运算符负号：'-'）。

• 运算的中间结果和最终结果也都为整数，且都不会产生异常（如除数为0等）。

• 暂且只支持如下几种运算符：+ - * / ( )

2. 中缀表达式与后缀表达式

算术表达式，根据运算符和运算数的相对位置不同，可以分为三种：前缀表达式（prefix）、中缀表达式（infix）和后缀表达式（postfix），其中后缀表达式又称为逆波兰式，在本文中只讨论中缀和后缀表达式。

• 中缀表达式：就是我们平时常见的算术表达式，如'1 + 2 * 3'，'( 1 + 2 ) * 3'这样的运算符在运算数中间的表达式，中缀表达式的特点是符合人的理解习惯，并且可以加小括号改变运算的先后顺序。但缺点是如果用编程来求值的话比较困难。

• 后缀表达式：是将中缀表达式进行变换后得到的表达式，如'1 2 3 * +'，'1 2 + 3 *'这样的运算符在运算数后面的表达式，后缀表达式的特点是虽然不符合人的理解习惯，但编程来求值却很方便，且没有括号的烦恼。

后缀表达式因为不需要括号，所以编程求值起来比较方便，下面将先从如何对后缀表达式求值讲起。

3. 后缀表达式求值

1. 核心算法：

（1） 创建一个空栈，名为numstack，用于存放运算数。

（2） 用python字符串的split函数将输入的后缀表达式（postfix）分割为列表，将该列表记为input。

（3） 从左到右遍历input的每一个元素token：

• 3.1：若token为运算数，将其转换为整数并push进numstack；

• 3.2：若token为运算符，则将numstack pop两次，将第一次pop得到的数作为运算符的右操作数，将第二次pop得到的数作为运算符的左操作数，然后求出运算结果，并将结果push进numstack；

（4）遍历完input后，numstack仅剩下一个元素，这就是表达式的最终求值结果，pop出这个元素，算法结束。

2. 举例

比如求'4 5 6 * +'这样一个后缀表达式的值（注：其前缀表达式为：'4 + 5 * 6'，值为34），按照上述算法，过程如下：

No.	operator	numstack
1		4
2		4 5
3		4 5 6
4	*	4 5 6
5		4 30
6	+	4 30
7		34

所以最终的表达式求值结果为：34

3. 代码实现

# 准备工作：创建一个栈类
class Stack():
    def __init__(self):
        self.data = []
    
    def __str__(self):
        return str(self.data)
    
    __repr__ = __str__
    
    def pop(self):
        if len(self.data) != 0:
            return self.data.pop()
        return None
    
    def push(self,e):
        self.data.append(e)
        
    def clear(self):
        del self.data[:]
    
    # 获取栈顶元素，但不弹出此元素
    def peek(self):
        if len(self.data) != 0:
            return self.data[-1]
        return None
    
    # 判断栈是否为空
    def empty(self):
        return len(self.data) == 0
    
# 求值函数
def get_value(num1,op,num2):
    if op == '+':
        return num1 + num2
    elif op == '-':
        return num1 - num2
    elif op == '*':
        return num1 * num2
    elif op == '/':
        return num1 / num2
    else:
        raise ValueError('invalid operator!')
    
# 后缀表达式求值函数
def get_postfix_value(postfix):
    # 1. 创建一个运算数栈
    numstack = Stack()
    
    # 2. 分割postfix
    inPut = postfix.strip().split()  # 注：因为'input'是内置函数名，所以用'inPut';strip函数的作用是去掉字符串的开始和结尾的空白字符
    
    # 3. 遍历inPut
    for token in inPut:
        # 3.1 如果token为运算数
        if token.isdigit():
            numstack.push(int(token))
        # 3.2 如果token是运算符
        else:
            num2 = numstack.pop()
            num1 = numstack.pop()
            numstack.push(get_value(num1,token,num2))
    
    # 4. 输出numstack的最后一个元素
    return numstack.pop()
            
# 后缀表达式
# 注：对应的中缀表达式为：(1+2)*(3+4)，运算结果为：21
postfix = '1 2 + 3 4 + *'

print '【Output】'
print get_postfix_value(postfix)

【Output】
21

4. 中缀表达式转后缀表达式

1. 核心算法

（1）创建一个空栈opstack，用于存放运算符，创建一个空列表output用于保存输出结果。

（2）使用python字符串的split函数将输入的中缀表达式（infix）字符串分割成列表并存入input列表中。

（3）从左到右遍历input列表的每个元素token：

• 3.1：若token是运算数，直接append到output中；

• 3.2：若token是运算符，先判断它与opstack栈顶元素的运算优先级（注：小括号的优先级约定为最低），若：token的优先级小于等于栈顶元素优先级，则先从opstack中pop出栈顶元素并append到output，再将token push进opstack；否则直接将token push进opstack；

• 3.3：若token是左括号，直接将其push进opstack；

• 3.4：若token是右括号，依次pop出opstack中的元素并依次append到output，直到遇到左括号，将左括号继续pop出（但不append到output）。

（4）当遍历完成input，将opstack中所有的剩余元素pop出并依次append到output。

（5）将output转换为字符串，即为最终求得的后缀表达式。

2. 举例

比如将'(A+B)*C'这样一个中缀表达式转换为后缀表达式（其中A,B,C表示整数），按照上述算法，转换过程如下：

No.	opstack	output
1	(
2	(	A
3	(+	A
4	(+	A B
5		A B +
6	*	A B +
7	*	A B + C
8		A B + C *

所以最终求得的后缀表达式为：'A B + C *'

3. 代码实现

# 准备工作：创建一个栈类
class Stack():
    def __init__(self):
        self.data = []
    
    def __str__(self):
        return str(self.data)
    
    __repr__ = __str__
    
    def pop(self):
        if len(self.data) != 0:
            return self.data.pop()
        return None
    
    def push(self,e):
        self.data.append(e)
        
    def clear(self):
        del self.data[:]
    
    # 获取栈顶元素，但不弹出此元素
    def peek(self):
        if len(self.data) != 0:
            return self.data[-1]
        return None
    
    # 判断栈是否为空
    def empty(self):
        return len(self.data) == 0
    
# 求值函数
def get_value(num1,op,num2):
    if op == '+':
        return num1 + num2
    elif op == '-':
        return num1 - num2
    elif op == '*':
        return num1 * num2
    elif op == '/':
        return num1 / num2
    else:
        raise ValueError('invalid operator!')
        
# 将中缀表达式转换为后缀表达式的函数
def infix2postfix(infix):
    # 1. 创建运算符栈和输出结果列表
    opstack = Stack()
    output = []
    
    # 准备一个运算符优先级字典，其中左小括号的优先级最低
    priority = {'(' : 0,'+' : 3,'-' : 3,'*' : 4,'/' : 4}
    
    # 2. 分割infix
    inPut = infix.strip().split()
    
    # 3. 遍历inPut
    for token in inPut:
        # 3.1 若token是运算数
        if token.isdigit():
            output.append(token)
        # 3.2 若token是运算符
        elif token in ['+','-','*','/']:
            if not opstack.empty() and priority[token] <= priority[opstack.peek()]:
                output.append(opstack.pop())
            opstack.push(token)
        # 3.3 若token是左括号
        elif token == '(':
            opstack.push(token)
        # 3.4 若token是右括号
        elif token == ')':
            while opstack.peek() != '(':
                output.append(opstack.pop())
            # 弹出左括号
            opstack.pop()
        else:
            raise ValueError('invalid token:{0}'.format(token))
    # 4. 将opstack中剩余元素append到output
    while not opstack.empty():
        output.append(opstack.pop())
        
    # 5. 将output转换为字符串（每个元素用空格隔开）并输出
    return ' '.join(output)

infix = '( 1 + 2 ) * ( 3 + 4 )'

print '【Output】'
print infix2postfix(infix)

【Output】
1 2 + 3 4 + *

5. 整理：中缀表达式求值

1. 核心算法

经过前面的讨论，那么现在求中缀表达式的值就很简单了，分为两步：第1步，将中缀表达式转换为对应的后缀表达式；第2步，对后缀表达式求值。

2. 完整代码实现

# 准备工作：创建一个栈类
class Stack():
    def __init__(self):
        self.data = []
    
    def __str__(self):
        return str(self.data)
    
    __repr__ = __str__
    
    def pop(self):
        if len(self.data) != 0:
            return self.data.pop()
        return None
    
    def push(self,e):
        self.data.append(e)
        
    def clear(self):
        del self.data[:]
    
    # 获取栈顶元素，但不弹出此元素
    def peek(self):
        if len(self.data) != 0:
            return self.data[-1]
        return None
    
    # 判断栈是否为空
    def empty(self):
        return len(self.data) == 0
    
# 求值函数
def get_value(num1,op,num2):
    if op == '+':
        return num1 + num2
    elif op == '-':
        return num1 - num2
    elif op == '*':
        return num1 * num2
    elif op == '/':
        return num1 / num2
    else:
        raise ValueError('invalid operator!')

# 将中缀表达式转换为后缀表达式的函数
def infix2postfix(infix):
    # 1. 创建运算符栈和输出结果列表
    opstack = Stack()
    output = []
    
    # 准备一个运算符优先级字典，其中左小括号的优先级最低
    priority = {'(' : 0,'+' : 3,'-' : 3,'*' : 4,'/' : 4}
    
    # 2. 分割infix
    inPut = infix.strip().split()
    
    # 3. 遍历inPut
    for token in inPut:
        # 3.1 若token是运算数
        if token.isdigit():
            output.append(token)
        # 3.2 若token是运算符
        elif token in ['+','-','*','/']:
            if not opstack.empty() and priority[token] <= priority[opstack.peek()]:
                output.append(opstack.pop())
            opstack.push(token)
        # 3.3 若token是左括号
        elif token == '(':
            opstack.push(token)
        # 3.4 若token是右括号
        elif token == ')':
            while opstack.peek() != '(':
                output.append(opstack.pop())
            # 弹出左括号
            opstack.pop()
        else:
            raise ValueError('invalid token:{0}'.format(token))
    # 4. 将opstack中剩余元素append到output
    while not opstack.empty():
        output.append(opstack.pop())
        
    # 5. 将output转换为字符串（每个元素用空格隔开）并输出
    return ' '.join(output)
    
# 后缀表达式求值函数
def get_postfix_value(postfix):
    # 1. 创建一个运算数栈
    numstack = Stack()
    
    # 2. 分割postfix
    inPut = postfix.strip().split()  # 注：因为'input'是内置函数名，所以用'inPut';strip函数的作用是去掉字符串的开始和结尾的空白字符
    
    # 3. 遍历inPut
    for token in inPut:
        # 3.1 如果token为运算数
        if token.isdigit():
            numstack.push(int(token))
        # 3.2 如果token是运算符
        else:
            num2 = numstack.pop()
            num1 = numstack.pop()
            numstack.push(get_value(num1,token,num2))
    
    # 4. 输出numstack的最后一个元素
    return numstack.pop()

# 中缀表达式求值函数
def get_infix_value(infix):
    postfix = infix2postfix(infix)
    return get_postfix_value(postfix)

infix = '( 1 + 2 ) * ( 3 + 4 )'

print '【Output】'
print get_infix_value(infix)

【Output】
21