✅DAY14 二叉树续 | 226.翻转二叉树 | 101. 对称二叉树 | 104.二叉树的最大深度 | 111.二叉树的最小深度

226.翻转二叉树

解题思路：最直接的就是递归，前序遍历

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root: return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)

        return root

解题思路：迭代法，深度优先遍历，前序遍历

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

解题思路：广度优先遍历（层序遍历）

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root: return None
        queue = collections.deque([root])

        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                node.left, node.right = node.right, node.left
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
        return root

*** 使用前后序解题思路是一致的，但是用中序需要注意root节点交换后，原右节点已到左节点，所以code上两遍操作都是左节点

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root: return None
        
        self.invertTree(root.left)
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        return root

101. 对称二叉树

解题思路：递归法。需要判断的左右是否存在空的情况，而且需要分外侧和内侧进行判断

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root: return None
        return self.compare(root.left, root.right)

    def compare(self, left, right):
        if left == None and right!= None: return False
        elif left != None and right== None: return False
        elif left == None and right == None: return True
        elif left.val != right.val: return False

        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        return outside and inside

解题思路：队列/栈判断其实一样的，只要把添加顺序定好弹出的内容都可以判断。深度遍历

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root: return None
        queue = collections.deque()
        queue.append(root.left)
        queue.append(root.right)
        while queue:
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if not leftNode and not rightNode:
                # 两者接为空
                continue
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            # 按照要比较的顺序进行添加
            queue.append(leftNode.left)
            queue.append(rightNode.right)
            queue.append(leftNode.right)
            queue.append(rightNode.left)
        return True

104.二叉树的最大深度

# 遍历
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        
        queue = collections.deque([root])
        depth = 0
        while queue:
            depth += 1
            for i in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return depth

# 递归
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        return self.getDepth(root)
        
    def getDepth(self, node):
        if not node:
            return 0
        leftHeight = self.getDepth(node.left)
        rightHeight = self.getDepth(node.right)
        height = 1 + max(leftHeight, rightHeight)
        return height

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root: return 0
        return 1 + max(self.maxDepth(root.left),self.maxDepth(root.right))

111.二叉树的最小深度

解题思路：迭代法

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

解题思路：递归法

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        
        leftDepth = self.minDepth(root.left)
        rightDepth = self.minDepth(root.right)

        # 如果某一子树为空，最小深度为另一子树的深度 + 1
        if root.left is None:
            return 1 + rightDepth
        if root.right is None:
            return 1 + leftDepth

        # 如果左右子树都不为空，取左右子树的较小深度 + 1
        return 1 + min(leftDepth, rightDepth)