[代码随想录-day_16]

#104. 二叉树的最大深度
第一想法：层序遍历（递归法/迭代法）
学习后：简单递归

# 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:
        # 层序遍历迭代法
        que = deque([root])
        res = []
        if not root:
            return 0
        while que:
            n = len(que)
            temp = []
            for _ in range(n):
                node = que.popleft()
                temp.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res.append(temp)
        # print(res)
        return len(res) 
        # 层序遍历递归法
        res = []
        def recursion(cur, depth):
            if not cur: return []
            if len(res) == depth:
                res.append([])
            res[depth].append(cur.val)
            if cur.left:
                recursion(cur.left,depth+1)
            if cur.right:
                recursion(cur.right,depth+1)
        recursion(root, 0)
        return len(res)
        # 题解学习递归
        if not root:
            return 0
        else:
            l = self.maxDepth(root.left)
            r = self.maxDepth(root.right)
            return max(l,r)+1

#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:
    	# 迭代法
    	que = deque([root])
        if not root:
            return 0
        res = []
        depth = 1
        while que:
            # temp = []
            depth += 1
            # print(que,depth)
            for _ in range(len(que)):
                node = que.popleft()
                # temp.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                if not node.left and not node.right:
                    return depth-1
        return depth
    	# 递归法
        def recursion(node):
            if not node:
                return 0
            if not node.left and not node.right:
                return 1
            l = recursion(node.left)
            r = recursion(node.right)
            if not node.left and node.right:
                return 1 + r 
            if node.left and not node.right:
                return 1 + l 
            res = min(l,r) + 1
            return res 
        return recursion(root)

#222. 完全二叉树的节点个数
第一想法：迭代法，yyds，递归法难以掌握

# 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 countNodes(self, root: Optional[TreeNode]) -> int:
        que = deque([root])
        if not root:
            return 0
        cnt = 0
        while que:
            num = 0
            for _ in range(len(que)):
                node = que.popleft()
                num += 1
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            cnt += num
        return cnt

递归法学习链接：学了之后，感叹递归法代码真的好短，也很好想，但是自己想就是想不到