六、二叉树（2）

226.翻转二叉树 （优先掌握递归

递归要考虑二叉树用的哪种遍历，也就是先执行操作，遍历左子树，右子树的顺序

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if root is None:
            return 
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root # 返回头节点，有且仅返回头节点，其他的都进递归啦

注意
直接一个return返回头节点，其他节点都不会返回

101. 对称二叉树 （优先掌握递归）

对称，和根节点无关，看左右子树，对左右子树递归，看左边是不是等于右边

104.二叉树的最大深度 （优先掌握递归）

111.二叉树的最小深度 （优先掌握递归）

1、递归：
递归参数、递归的终止条件、递归的单层逻辑（前序遍历 or 后序遍历）

class Solution:
   def minDepth(self, root: Optional[TreeNode]) -> int:
       if root is None:
           return 0
       minleft = self.minDepth(root.left)
       minright = self.minDepth(root.right)
       if root.left and not root.right:
           dep = minleft
       elif root.right and not root.left:
           dep = minright
       else:
           dep = min(minleft, minright)

       return dep + 1

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 minDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        queue = collections.deque([root])
        dep = 0

        while queue:
            dep += 1
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)

                if not node.left and not node.right:
                    #找到一个最小了
                    return dep 
                
            

注意：+1不应该在节点node里面，应该在层里面，达到迭代退出条件是在中途遇到左右子树都为空。