表達樹構造

表達樹構造

問題

表達樹是一個二叉樹的結構，用於衡量特定的表達。所有表達樹的葉子都有一個數字字符串值。而所有表達樹的非葉子都有另一個操作字符串值。

給定一個表達數組，請構造該表達的表達樹，並返回該表達樹的根。
例子
對於 (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)