leetcode算法训练十四天| 104.二叉树的最大深度，111.二叉树的最小深度，222.完全二叉树的节点个数

104.二叉树的最大深度

学习视频：二叉树的高度和深度有啥区别？究竟用什么遍历顺序？很多录友搞不懂 | LeetCode：104.二叉树的最大深度_哔哩哔哩_bilibili

学习文档：代码随想录 (programmercarl.com)

学习时间：14：20-15：00

记录时间：15：05-15:20

状态：已听懂|可单独复写代码|需复习

1. 看到问题后的初始想法与看完随想录后的心得

        本题我以前居然做过？？？我已经完全记不得了。。。

        本题还是使用递归的方法（迭代、回溯等算法第一遍刷题暂且不学，因为最近比较忙，先把最基本的刷完就行）这里就又要搬出迭代的基本三法则了。

1. 我们首先需要确认递归的输入值和返回值。求解最大深度的输入值为要求解的树的根节点，返回值是整数（代表深度）
2. 其次，我们需要确认递归的终止条件，本方法递归的终止条件为：若求解的根节点为空值，则返回0.
3. 最后，我们需要确定我们每一层遍历的逻辑，在这里我们采用后序遍历，即我们先求出左子树的深度，再求出右子树的深度，最后当前节点的深度即为左子树的深度与右子树的深度的最大值再加上1.

代码如下：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def get_max_height(root):
            if root is None:
                return 0
            leftheight = get_max_height(root.left)
            rightheight = get_max_height(root.right)
            currentheight = 1 + max(leftheight, rightheight)
            return currentheight
        height = get_max_height(root)
        return height

111.二叉树的最小深度

学习视频：看起来好像做过，一写就错！ | LeetCode：111.二叉树的最小深度_哔哩哔哩_bilibili

学习文档：代码随想录 (programmercarl.com)

学习时间：15:35-16:04

记录时间：16:04-16：30

状态：已听懂|可单独复写代码|需复习

 1. 看到问题后的初始想法与看完随想录后的心得

        我看到这一题后的第一反应就是和第一题完全相同，只不过在递归中把左右子树的最大值+1改成左右子树的最小值+1.不过后来看了视频后才发现并不是这样的，如果根节点的左子树为0，那该根节点的最小深度不是1而是1+最右节点的最小值。因此在递归过程中我们还需要在每一层的处理中加一些判定条件，具体思路如下：

1. 递归的输入值与输出值。输入值为某个根节点，输出值为该根节点的最小深度。
2. 递归的终止条件。当递归中我们遇到子节点为空时，即代表已经遍历到叶子节点的左/右儿子，此时应该返回0
3. 递归中每一层的处理。依旧采用后续遍历法，首先得到左子树的最小深度，然后得到右子树的最小深度。在更新中间节点时，我们还要判断中间节点的左右子树是否为空，若左节点为空右节点非空，则输出右节点的最小深度+1，反之则输出左节点的最小深度+1.若左右非空或者左右皆为空，则输出最小的左右节点最小深度+1.

代码如下：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def get_min(root):
            if root is None:
                return 0
            left_min = get_min(root.left)
            right_min = get_min(root.right)
            if root.left is None and root.right is not None:
                return 1 + right_min
            elif root.right is None and root.left is not None:
                return 1 + left_min
            else:
                return 1 + min(left_min, right_min)
        result = get_min(root)
        return result

222.完全二叉树的节点个数

学习视频：要理解普通二叉树和完全二叉树的区别！ | LeetCode：222.完全二叉树节点的数量_哔哩哔哩_bilibili

学习文档：代码随想录 (programmercarl.com)

学习时间：19:14-19:37

记录时间：19:37-19：50

状态：已听懂|可单独复写代码|需复习

  1. 看到问题后的初始想法与看完随想录后的心得

        第一次看到这题我的第一反应就是使用死的递归方法，对每一个节点都进行遍历，但是我很快就发现了自己算法可能不是最优的——因为我完全没有用到题目中的完全二叉树。故直接看了学习视频，我才发现如何去优化这个算法：在死板的递归全部遍历之上，我还需要再加一个终止条件——判断该节点所有左节点的深度与该节点所有右节点的深度是否相同，如果相同则为满二叉树，因此我们只需要使用公式2**K-1即可（K为深度）递归三部曲如下所示：

1. 递归的输入与输出：该递归输入树节点即可，输出包括该树节点的总个数
2. 递归的终止条件：这里存在两个终止条件，第一个终止条件为当前节点为空，第二个终止条件为左节点的左深度等于右节点的右深度。
3. 递归的每层处理：对当前节点的左子树进行递归，对右子树进行递归，最后将左右子树的递归结果（即左右子树的个树）相加再加1（加上自身）

代码如下：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def countNodes(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        def count(root):
            if root is None:
                return 0
            left = root.left
            right = root.right
            left_depth = 0
            right_depth = 0
            while left:
                left = left.left
                left_depth += 1
            while right:
                right = right.right
                right_depth += 1
            if right_depth == left_depth:
                return 2 ** (left_depth + 1) - 1
            left_num = count(root.left)
            right_num = count(root.right)
            return left_num + right_num + 1
        result = count(root)
        return result

​​​​​​​