python实现中序遍历表达式二叉树，前缀、中缀、后缀表达式生成表达式二叉树

# coding:UTF8

class TNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    # 判断是否是运算符
    def isOper(self, ch):
        if ch in ['+', '-', '*', '/', '^', '(', ')']:
            return True
        return False
    
    # 获取运算符所对应的优先级别
    def getOperOrder(self, ch):
        if ch == '(':
            return 1
        if ch in ['+', '-']:
            return 2
        if ch in ['*', '/']:
            return 3
        if ch == '^':
            return 4
    　　 return 0
　　　　　　

    # 中序遍历表达式二叉树
    def InorderTree(self, pNode):
        if not pNode:
            return
        if pNode.left:
            # 如果左子树是符号，且优先级低于父节点的优先级则需要加括号
            if self.isOper(pNode.left.val) and self.getOperOrder(pNode.left.val) < self.getOperOrder(pNode.val):
                res.append('(')
                self.InorderTree(pNode.left)
                res.append(')')
            else:
                self.InorderTree(pNode.left)
        res.append(pNode.val)
        if pNode.right:
            # 如果有子树是符号且优先级低于父节点的优先级，则需要加括号
            if self.isOper(pNode.right.val) and self.getOperOrder(pNode.right.val) <= self.getOperOrder(pNode.val):
                res.append('(')
                self.InorderTree(pNode.right)
                res.append(')')
            else:
                self.InorderTree(pNode.right)
    
    # 创建二叉树
    def createTree(self, data):
        if not data:
            return
        ch = data.pop(0)
        if ch == '#':
            return None
        else:
            root = TNode(ch)
            root.left = self.createTree(data)
            root.right = self.createTree(data)
            return root   
    
    # 后缀表达式生成二叉树
    def PostExpTree(self, data):
        if not data:
            return
        re = []
        while data:
            tmp = data.pop(0)
            if not self.isOper(tmp):
                re.append(TNode(tmp))
            else:
                p = TNode(tmp)
                p.right = re.pop()
                p.left = re.pop()
                re.append(p)
        return re.pop()
    
    # 前缀表达式生成二叉树
    def PreExpTree(self, data):
        re = []
        while data:
            tmp = data.pop()
            if not self.isOper(tmp):
                re.append(TNode(tmp))
            else:
                p = TNode(tmp)
                p.left = re.pop()             
                p.right = re.pop()             
                re.append(p)
        return re.pop()
    
    # 中缀表达式生成二叉树
    def InExpTree(self, data):
        re = []
        op = []
        while data:
            tmp = data.pop(0)
            if not self.isOper(tmp):
                re.append(tmp)
            else:
                if tmp == '(':
                    op.append('(')
                elif tmp == ')':
                    while op[-1] != '(':
                        re.append(op.pop())
                    op.pop()
                elif tmp in ['+', '-', '*', '/']:
                    while op and op[-1] != '(' and self.getOperOrder(op[-1]) >= self.getOperOrder(tmp):
                        re.append(op.pop())
                    op.append(tmp)
        if op:
            re = re + op[::-1]
        print re
        return self.PostExpTree(re)
    
           
data = ['*', 3, '#', '#', '-', 7, '#', '#', 2, '#', '#']   
s = Solution()
t1 = s.createTree(data)
# t1 = s.PostExpTree([3, 7, 2, '-', '*'])
# t1 = s.PreExpTree(['*', 3, '-', 7, 2])
# t1 = s.InExpTree([9, '+', '(', 3, '-', 1, ')', '*', 3, '+', 10, '/', 2])
res = []
s.InorderTree(t1)
res = map(str, res)
print ''.join(res)  

结果：