DAY17 代码随想录 二叉树part04

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:
        if not root: return True
        return abs(self.height(root.right)-self.height(root.left)) <2 and self.isBalanced(root.left) and self.isBalanced(root.right)
    # 求高度
    def height(self,node):
        if not node:
            return 0
        return 1 +max(self.height(node.left),self.height(node.right))

257. 二叉树的所有路径

递归

首先递归2部曲

• 1.找出重复的子问题
  将根节点加入路径，递归左子树，递归右子树
• 2.确定终止条件
  当遍历到叶子节点时，当前路径结束，添加该路径到结果中

if not node.left and not node.right:
    res.append(path)

法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 binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        # DFS 深度优先搜索
        res = []
        def dfs_path(root,path):
            if root:
                path+=str(root.val)
                if not root.left and not root.right: # 当前节点是叶子节点
                    res.append(path)
                else:
                    # 当前节点不是叶子节点
                    path+='->'
                    dfs_path(root.left,path)
                    dfs_path(root.right,path)
        dfs_path(root,'')
        return res

法2

# 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 binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        res = []
        self.getPath(root,'',res)
        return res
    def getPath(self,root,path,res):
        if not root:return 
        # 若节点不为空 则将当前节点的值加到路径中
        path += str(root.val)
        # 若当前节点为叶子节点 则直接返回path到res中
        if not root.left and not root.right:
            res.append(path)
        # 否则继续遍历左子树 遍历右子树
        else:
            path+='->'
            self.getPath(root.left,path,res)
            self.getPath(root.right,path,res)

时间复杂度O(n) 空间复杂度O(n)

迭代法

首先迭代法一般用栈做，由于本题目还需要记录路径，则我们还需要一个额外的栈来存储路径。
因此需要先将根节点入栈，然后右子树，最后左子树。

# 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 binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        """
        stack:递归栈
        pathstack:路径栈
        res:结果
        """
        stack = [root]
        pathstack = []
        pathstack.append(str(root.val))
        res = []

        while stack:
            node, path = stack.pop(), pathstack.pop()
            if node.right:
                stack.append(node.right)
                pathstack.append(path+"->"+str(node.right.val))
            if node.left:
                stack.append(node.left)
                pathstack.append(path+"->"+str(node.left.val))
            if not node.right and not node.left:
                res.append(path)
        return res

404.左叶子之和

迭代法

迭代法需要构造栈来辅助
如果遍历到当前节点的左子树存在，且其左子树无孩子节点则sum+=no.val。如果该左子树有孩子节点则将其压入栈中。
如果遍历到当前节点的右子树存在，则将右子树压入栈中。

# 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
        sum = 0
        stack = [root]
        while stack:
            node = stack.pop()
            if node.left and not node.left.left and not node.left.right:
                sum+=node.left.val
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return 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 sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        leftsum = 0
        def dfs(node):
            # nonlocal关键字用来在函数或其他作用域中使用并修改外层(非全局)变量
            nonlocal leftsum
            if not node:return None
            if node.left and not node.left.left and not node.left.right:
                leftsum += node.left.val
            dfs(node.left)
            dfs(node.right)
        dfs(root)
        return leftsum