代码随想录算法训练营第十四天 | 226.翻转二叉树、101. 对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度

226.翻转二叉树

就是个深搜，先翻转左右子树，再递归调用，让自己的子树也翻转。最终所有的子树翻转一次，总体就翻转过来了。

递归写法：

# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

迭代写法：也就是个前序遍历。

# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        stack = [root]

        while stack:
            cur = stack.pop()

            cur.left, cur.right = cur.right, cur.left

            if cur.right:
                stack.append(cur.right)
            if cur.left:
                stack.append(cur.left)

        return root

101. 对称二叉树

递归很容易，因为根节点不用管，所以构造一个辅助函数即可。

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        def isEqual(left, right):
            if not left and not right:
                return True
            if not right or not left:
                return False            
            return left.val == right.val and isEqual(left.left, right.right) and isEqual(left.right, right.left)
        return isEqual(root.left, root.right)

迭代：

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True

        stack = [root.left, root.right]

        while stack:
            right = stack.pop()
            left = stack.pop()

            if not right and not left:
                continue
            
            if not right or not left or right.val != left.val:
                return False
            
            stack.append(left.left)
            stack.append(right.right)
            stack.append(left.right)
            stack.append(right.left)
        return True

104.二叉树的最大深度

这题一下想到广搜..

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        depth = 0
        if not root:
            return 0
        que = collections.deque([root])

        while que:
            depth += 1
            for i in range(len(que)):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return depth

递归也不难~当前层的最大深度=左子树右子树的最大深度+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 maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0

        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

111.二叉树的最小深度

这题因为只有到叶子节点才算一个路径，这里用闭包传递。

# 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 minDepth(self, root: Optional[TreeNode]) -> int:
        d = float('inf')

        def dfs(root, h):
            nonlocal d
            if not root.left and not root.right:
                return min(d, h + 1)
            if root.left:
                d = dfs(root.left, h + 1)
            if root.right:
                d = dfs(root.right, h + 1)
            return d

        return dfs(root, 0) if root else 0

理解一下题解方法，

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0

        if not root.left and root.right:
            return 1 + self.minDepth(root.right)
        elif not root.right and root.left:
            return 1 + self.minDepth(root.left)
        else:
            return 1 + min(self.minDepth(root.left), self.minDepth(root.right))

感觉上差不多，这里对非叶子节点做了判断，在不是叶子节点的地方不去做比较。

迭代：从上往下遇到第一个叶子节点就是最小深度。

# 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 minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        
        que = collections.deque([root])
        level = 0
        while que:
            level += 1
            for i in range(len(que)):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
                if not cur.left and not cur.right:
                    return level