Leetcode| 110. 平衡二叉树、257. 二叉树的所有路径、404. 左叶子之和 Day17

110. Balanced Binary Tree

后续遍历，判断每个节点的左右子树高度差是否大于1

# 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:

        def getHeight(node):
            if node == None:
                return 0

            leftHeight = getHeight(node.left)       # 左
            if leftHeight == -1: return -1
            rightHeight = getHeight(node.right)     # 右
            if rightHeight == -1: return -1

            res = None
            if abs(leftHeight - rightHeight) > 1:   # 中
                res = -1
            else:
                res = 1 + max(leftHeight, rightHeight)

            return res

        if getHeight(root) == -1:
            return False
        else:
            return True

---

257. Binary Tree Paths

前序遍历
回溯和递归是一一对应的，有一个递归，就要有一个回溯

# 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 __init__(self):
        self.res = []
    def preOrderTraversal(self, node, path, res):
        path.append(node)       # 中
        if node.left == None and node.right == None:    # 到达叶子节点
            strPath = ''
            for i in range(len(path) - 1):
                strPath += str(path[i].val)
                strPath += '->'
            strPath += str(path[-1].val)
            res.append(strPath)

        if node.left:
            self.preOrderTraversal(node.left, path, res)     # 左
            path.pop()              # 回溯

        if node.right:
            self.preOrderTraversal(node.right, path, res)    # 右
            path.pop()              # 回溯

    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        self.preOrderTraversal(root, [], self.res)
        return self.res

---

404. Sum of Left Leaves

只能通过父节点判断是否是左叶子节点

递归后序遍历

当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。

# 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
        
        left_left_leaves_sum = self.sumOfLeftLeaves(root.left)  # 左
        right_left_leaves_sum = self.sumOfLeftLeaves(root.right) # 右
        
        cur_left_leaf_val = 0
        if root.left and not root.left.left and not root.left.right: 
            cur_left_leaf_val = root.left.val 
            
        return cur_left_leaf_val + left_left_leaves_sum + right_left_leaves_sum # 中

直接遍历每个节点累积

随便用哪种遍历方法，遇到左叶子将值累积

# 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 __init__(self):
        self.res = 0
        
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        def postOrderTraversal(node):
            if node == None:
                return
            if node.left != None and node.left.left == None and node.left.right == None:
                self.res += node.left.val
            postOrderTraversal(node.left)
            postOrderTraversal(node.right)

        postOrderTraversal(root)
        return self.res