leetcode刷题(python)110.平衡二叉树& 257. 二叉树的所有路径 &404.左叶子之和

110.平衡二叉树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        return self.getheight(root)!=-1
    def getheight(self,node):
        if not node:
            return 0
        left = self.getheight(node.left)
        right = self.getheight(node.right)
        if left==-1 or right==-1 or abs(left-right)>1:
            return -1
        return 1+max(left,right)

递归后序遍历-左右中

 257. 二叉树的所有路径

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def traversal(self,cur,path,result):
        path.append(cur.val)
        if not cur.left and not cur.right:
            spath = '->'.join(map(str,path))
            result.append(spath)

        if cur.left:
            self.traversal(cur.left,path,result)
            path.pop()
        if cur.right:
            self.traversal(cur.right,path,result)
            path.pop()
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        result = []
        path = []
        if not root:
            return result
        self.traversal(root,path,result)
        return result

 回溯法有意思但挺难，需多巩固

404.左叶子之和 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        if not root.left and not root.right:
            return 0
        valueleft = self.sumOfLeftLeaves(root.left)
        if  root.left and not root.left.left and not root.left.right :
            valueleft =  root.left.val
        valueright =self.sumOfLeftLeaves(root.right)
        return valueleft+valueright
        

后序遍历递归，最关键是判断左子树与右子树的左叶子之和，关键判断终止条件