代码随想录算法训练营第十六天|104. 二叉树的最大深度、559. N 叉树的最大深度、111. 二叉树的最小深度、222. 完全二叉树的节点个数

【参考链接】

104. 二叉树的最大深度

【注意】

1.

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）。
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）。

2.根节点的高度就是二叉树的最大深度，所以本题中我们通过后序求的根节点高度来求的二叉树最大深度。

3.通过后序把结果传递给父节点，父节点再加1。

4.真正求深度是用前序。

5.最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

【代码】

# 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
        """
        #1.递归法
        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

559. N 叉树的最大深度

【代码】

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: Node
        :rtype: int
        """
        #1.迭代法
        if not root:
            return 0
        
        max_depth = 1

        for child in root.children:
            max_depth = max(max_depth, self.maxDepth(child)+1)
        return max_depth

111. 二叉树的最小深度

【注意】

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

2.前序求的是深度，后序求的是高度。

3.使用后序遍历，其实求的是根节点到叶子节点的最小距离，就是求高度的过程，不过这个最小距离 也同样是最小深度。

【代码】

# 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
        """
        #1.递归法
        if not root:
            return 0
        if not root.left and not root.right:
            return 1
        
        left_depth = float('inf')
        right_depth = float('inf')

        if root.left:
            left_depth = self.minDepth(root.left)
        if root.right:
            right_depth = self.minDepth(root.right)
        
        return 1 + min(left_depth, right_depth)

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

【注意】

1.后序遍历实现起来比较简单一些。

2.判断子树是否是满二叉树，利用公式2^k-1。

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
        """
        #完全二叉树写法
        if not root:
            return 0
        left = root.left
        right = root.right
        leftDepth = 0
        rightDepth = 0
        #求左子树深度
        while left:
            left = left.left
            leftDepth += 1
        while right:
            right = right.right
            rightDepth += 1
        if leftDepth == rightDepth:
            #注意(2<<1) 相当于2^2，所以leftDepth初始为0
            return (2 << leftDepth) - 1
        return self.countNodes(root.left) + self.countNodes(root.right) + 1
    #     return self.getNodesNum(root)
    # #普通二叉树的递归方法
    # def getNodesNum(self, node):
    #     if not node:
    #         return 0
    #     leftNum = self.getNodesNum(node.left)
    #     rightNum = self.getNodesNum(node.right)
    #     treeNum = leftNum + rightNum + 1

    #     return treeNum