第十七天|二叉树

今天还是二叉树，与前几天相比，今天逐渐有点理解前序和后序遍历的区别与使用场景了

110. Balanced Binary Tree

这就是一道典型的后序遍历的题，需要分别得到左右子树的结果并判断之后来确定最后的return值

Way1：

基本思路就是对于每个节点，得到其左右子树的高度，然后进行判断，如果满足要求则返回自己的最大高度

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        def getheight(node):
            if not node:
                return 0
            l=getheight(node.left)
            r=getheight(node.right)
            if l==-1 or r==-1:
                return -1
            if abs(l-r) >1:
                return -1
            return max(l,r)+1
        if getheight(root) ==-1:
            return False
        return True

257. Binary Tree Paths

这道题主要就是一个回溯，用dfs或者bfs都可以

Way1：

用recursion，需要回溯。recursion过程中先把当前的node值加到path里面，然后最左右子树的不同情况做判断

class Solution(object):
    def binaryTreePaths(self, root):
        """
        :type root: TreeNode
        :rtype: List[str]
        """
        result=[]
        def find(path,node):
            path=path+"->"+str(node.val)
            if node.left ==None and node.right==None:
                result.append(path[2:])
            elif node.left ==None:
                find(path,node.right)
            elif node.right==None:
                find(path,node.left)
            else:
                find(path,node.left)
                find(path,node.right)
    
        find("",root)
        return result

Way2：

用bfs， 基本判断思路和way1是一致的

class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        q=deque()
        path_st=deque()
        res=[]
        if not root:
            return res
        q.append(root)
        path_st.append(str(root.val))
        while q:
            path=path_st.popleft()
            node=q.popleft()
            if not node.left and not node.right:
                res.append(path)
            if node.left:
                path_st.append(path+"->"+str(node.left.val))
                q.append(node.left)
            if node.right:
                path_st.append(path+"->"+str(node.right.val))
                q.append(node.right)
        return res

404. Sum of Left Leaves

这道题的难点在于理解leave node。叶子节点既没有左子树也没有右子树。

Way1：

遍历所有的node，中途判断当前node的左node是不是leave node

class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        def recur(node):
            if not node:
                return 0
            l=recur(node.left)
            if node.left and not node.left.left and not node.left.right:
                l=node.left.val
            r=recur(node.right)
            return l+r
        return recur(root)