算法学习|Day16-二叉树|Leetcode104.二叉树的最大深度，Leetcode111.二叉树的最小深度，Leetcode222.完全二叉树的节点个数

一、Leetcode104.二叉树的最大深度

题目描述

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

输入：root = [3,9,20,null,null,15,7]
输出：3

输入：root = [1,null,2]
输出：2

题目链接：力扣题目链接

解题思路

• 可以使用递归(前序遍历，后序遍历)
• 可以使用层序遍历

方法一:递归

• 递归三部曲：

1.确定递归函数的参数和返回值：
传入的就是根节点，返回的是深度

2.确定终止条件：
遍历到空节点的时候，返回0

        if not root:
            return 0

3.确定单层递归逻辑：
使用后序遍历，先遍历得到左子树的深度，再遍历右子树的深度，当前根节点的最大深度就是1+max(左子树深度，右子树深度)

		numleft = self.maxDepth(root.left)
        numright = self.maxDepth(root.right)
        total = 1 + max(numleft, numright)

总代码：

# 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

        numleft = self.maxDepth(root.left)
        numright = self.maxDepth(root.right)
        total = 1 + max(numleft, numright)
        return total
          

方法二:层序遍历

• 跟day15使用的层序遍历框架类似
• 遍历完每一层+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
        que = collections.deque([root])
        num = 0
        while que:
            size = len(que)
            for _ in range(size):
                cur =  que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            num += 1
        return num 
          

总结

• 递归：递归三部曲！！！可以使用叶子节点做单层递归的检验
• 层序遍历：当每一层的size循环结束后计数+1，遍历到最后一层返回计数num

---

二、Leetcode111.二叉树的最小深度

题目描述

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

输入：root = [3,9,20,null,null,15,7]
输出：2

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

题目链接：力扣题目链接

解题思路

• 可以使用递归(前序遍历和后序遍历)

方法:递归

1.确定递归函数的参数和返回值：
传入的就是根节点，返回的是深度

2.确定终止条件：
遍历到空节点的时候，返回0

        if not root:
            return 0

3.确定单层递归逻辑：
使用后序遍历，先遍历得到左子树的深度，再遍历右子树的深度，当前根节点的最小深度要分情况：
当左子树和右子树都不为空时，最小深度=1+min(左子树深度，右子树深度)；
当左子树或右子树为空，都为空时，最小深度=1+左子树深度+右子树深度。

		numleft = self.minDepth(root.left)
        numright = self.minDepth(root.right)
        if numleft!=0 and numright!=0:
            total = 1 + min(numleft, numright)
        else:
            total = 1 + numleft + numright
        return total

总代码：

# 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

        numleft = self.minDepth(root.left)
        numright = self.minDepth(root.right)
        if numleft!=0 and numright!=0:
            total = 1 + min(numleft, numright)
        else:
            total = 1 + numleft + numright
        return total

总结

• 最小深度和最大深度不一样，有坑！！！因为最小深度的计算是到叶子节点！！！
• 基本思路还是递归三部曲，只是单层递归的思路多了不同情况的判断

---

三、Leetcode222.完全二叉树的节点个数

题目描述

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

输入：root = [1,2,3,4,5,6]
输出：6

输入：root = []
输出：0

输入：root = [1]
输出：1

题目链接：力扣题目链接

解题思路

• 使用递归(后序遍历)
• 使用层序遍历

方法一:递归

1.确定递归函数的参数和返回值：
传入的就是根节点，返回的是节点个数

2.确定终止条件：
遍历到空节点的时候，返回0

        if not root:
            return 0

3.确定单层递归逻辑：
使用后序遍历，先求左子树的节点数量，再求右子树的节点数量，最后根节点+1

		numleft = self.countNodes(root.left)
        numright = self.countNodes(root.right)
        total = 1 + numleft + numright
        return total

总代码：

# 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:
        # 递归
        if not root:
            return 0

        numleft = self.countNodes(root.left)
        numright = self.countNodes(root.right)
        total = 1 + numleft + numright
        return total

方法二:层序遍历

• 使用层序遍历的代码框架
• 将每一层的size相加就是节点数量，累计到层序遍历完成

# 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:
        # 层序遍历
        if not root:
            return 0
        que = collections.deque([root])
        num = 0

        while que:
            size = len(que)
            for _ in range(size):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            num = num + size
        return num
        

总结

• 递归：重点是选择对：前中后序遍历中哪一个，找到单层递归的逻辑就可以了
• 层序遍历比较熟练了！

---

心得：进入刷题的状态啦，昨天跟npy讨论了一下递归的方法算是彻底掌握了，所以今天的几道递归题目写的都比较顺利！非常开心！继续努力啦！