代码随想录算法训练营Day12 | 226. 翻转二叉树，101. 对称二叉树，104. 二叉树的最大深度，111. 二叉树的最小深度-优快云博客

226. 翻转二叉树

题目链接：226. 翻转二叉树 - 力扣（LeetCode）

文章讲解：代码随想录

解题卡点：无

# 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
        def invert(node):
            if node is None:
                return
            node.left, node.right = node.right, node.left
            invert(node.left)
            invert(node.right)      
        invert(root)
        return root

    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        stack = []
        if root:
            stack.append(root)
        while stack:
            node = stack.pop()
            if node != None:
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
                stack.append(node)
                stack.append(None)
            else:
                node = stack.pop()
                node.left, node.right = node.right, node.left
        return root

    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        queue = collections.deque([])
        if root:
            queue.append(root)
        while queue:
            level_size = len(queue)
            for _ in range(level_size):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                node.left, node.right = node.right, node.left
        return root

101. 对称二叉树

题目链接：101. 对称二叉树 - 力扣（LeetCode）

文章讲解：代码随想录

解题卡点：有一点思路，但不多

# 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 compare(node_left, node_right):
            if node_left != None and node_right == None:
                return False
            elif node_left == None and node_right != None:
                return False
            elif node_left == None and node_right == None:
                return True
            elif node_left.val != node_right.val:
                return False         
            outside = compare(node_left.left, node_right.right)
            inside = compare(node_left.right, node_right.left)
            isSame = outside and inside
            return isSame
        return compare(root.left, root.right)

    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        queue = collections.deque([])
        queue.append(root.left)
        queue.append(root.right)
        while queue:
            left_node = queue.popleft()
            right_node = queue.popleft()
            if not left_node and not right_node:
                continue
            if not left_node or not right_node or left_node.val != right_node.val:
                return False
            queue.append(left_node.left)
            queue.append(right_node.right)
            queue.append(left_node.right)
            queue.append(right_node.left)
        return True

104. 二叉树的最大深度

题目链接：104. 二叉树的最大深度 - 力扣（LeetCode）

文章讲解：代码随想录

解题卡点：还是不熟悉递归

# 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:
        def get_depth(node):
            if not node:
                return 0
            left_depth = get_depth(node.left)
            right_depth = get_depth(node.right)
            node_depth = 1 + max(left_depth, right_depth)
            return node_depth
        return get_depth(root)

    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        res = 0
        queue = collections.deque([root])
        while queue:
            level = []
            level_size = len(queue)
            for _ in range(level_size):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            res += 1
        return res

111. 二叉树的最小深度

题目链接：111. 二叉树的最小深度 - 力扣（LeetCode）

文章讲解：代码随想录

解题卡点：还是不熟悉递归

# 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:
        def get_depth(node):
            if not node:
                return 0
            left_depth = get_depth(node.left)
            right_depth = get_depth(node.right)
            if node.left is None and node.right is not None:
                return 1 + right_depth
            if node.left is not None and node.right is None:
                return 1 + left_depth      
            node_depth = 1 + min(left_depth, right_depth)
            return node_depth
        return get_depth(root)

    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        res = 0
        queue = collections.deque([root])
        while queue:
            res += 1
            level_size = len(queue)
            for _ in range(level_size):
                cur = queue.popleft()
                if not cur.left and not cur.right:
                    return res

                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return res