表达树构造

表达树构造

问题

表达树是一个二叉树的结构，用于衡量特定的表达。所有表达树的叶子都有一个数字字符串值。而所有表达树的非叶子都有另一个操作字符串值。

给定一个表达数组，请构造该表达的表达树，并返回该表达树的根。
例子
对于 (2*6-(23+7)/(1+2)) 的表达（可表示为 [“2” “*” “6” “-” “(” “23” “+” “7” “)” “/” “(” “1” “+” “2” “)”]).
其表达树如下：

             [ - ]
         /          \
    [ * ]              [ / ]
  /     \           /         \
[ 2 ]  [ 6 ]      [ + ]        [ + ]
                 /    \       /      \
               [ 23 ][ 7 ] [ 1 ]   [ 2 ] .

在构造该表达树后，你只需返回根节点[-]。

思路

对所有操作符号 设置等级 + or - 1级 * or / 2级 对于括号包裹内容 提升2级。然后递归构建表达树

实现

#!/usr/bin/env python
# coding=utf-8
class ExpressionTreeNode:
    def __init__(self, symbol):
        self.symbol = symbol
        self.left, self.right = None, None
class Solution:
    # @param expression: A string list
    # @return: The root of expression tree
    def build(self, expression):
        # write your code here
        exp = self.filterBracket(expression)
        return self.buildChild(exp,self.initOperatorLevel(expression),0,len(exp))
    def initOperatorLevel(self,expression):
        level = []
        kuohao = 0
        for i,symbol in enumerate(expression):
            if(symbol == '+' or symbol == '-'):
                level.append(1+kuohao)
                continue
            if symbol == '*' or symbol == '/':
                level.append(2+kuohao)
                continue
            if symbol == '(':
                kuohao += 2
                continue
            if symbol == ')':
                kuohao -= 2
                continue
            level.append(10000)
        return level

    def filterBracket(self,expression):
        return list(filter(lambda a:a != '(' and a != ')',expression))

    def buildChild(self,expression,level,start,end):
        m = 10000
        index = start
        if end - start <= 1:
            return ExpressionTreeNode(expression[start])
        #找到根节点
        for i in range(start,end):
            if(level[i]<=m):
                m = level[i]
                index = i
        root = ExpressionTreeNode(expression[index])
        root.left = self.buildChild(expression,level,start,index)
        root.right = self.buildChild(expression,level,index+1,end)
        return root

def order(root,result):
    if root:
        result.append(root.symbol)
        if root.left:

        else:
            result.append('#')
        if root.right:
            order(root.right,result)
        else:
            result.append('#')

        order(root.left,result)




if __name__ == '__main__':
    root = Solution().build(["2","*","6","-","(","23","+","7",")","/","(","1","+","2",")"])
    result = []
    order(root,result)
    print(result)