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

104.二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

思路1 迭代法 层序遍历

层序遍历的思路很简单，其结果本来就是按层数记录的，只需返回结果的长度皆可。

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root ==None:
            return 0
        queue = collections.deque([root])

        levels = []
        while queue:
            for _ in range(len(queue)):
                level = []
                node = queue.popleft()
                level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            levels.append(level)
        return len(levels)

思路2 递归法 前序/后序遍历

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）
使用前序（中左右）求的就是深度，使用后序（左右中）求的是高度。
根节点的高度就是二叉树的最大深度

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        return self.getdepth(root)
    
    def getdepth(self,node):
        if node == None:
            return 0
        leftdepth = self.getdepth(node.left)
        rightdepth = self.getdepth(node.right)
        depth = 1 + max(leftdepth,rightdepth)
        return depth

111.二叉树的最小深度

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

思路1 层序遍历

一层层遍历过去，当有节点没有子节点时返回当前层数.

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        queue = collections.deque([root])
        cnt = 1
        while queue:
            for _ in range(len(queue)):        
                node = queue.popleft()
                if node.left==None and node.right==None:
                    return cnt
                else:
                    if node.left:
                        queue.append(node.left)
                    if node.right:
                        queue.append(node.right)
            cnt += 1

思路2 后序遍历

如果左子树空，右子树不空，则最小深度时1+右子树深度
如果右子树空，左子树不空，则最小深度时1+左子树深度
如果都不空，则最小深度为左右子树深度最小值+1

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        return self.getdepth(root)
    
    def getdepth(self,node):
        if node == None:
            return 0
        leftdepth = self.getdepth(node.left)
        rightdepth = self.getdepth(node.right)

        if node.left == None and node.right != None:
            return rightdepth + 1
        if node.left != None and node.right == None:
            return leftdepth + 1
        
        res = 1 + min(leftdepth,rightdepth)
        return res

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

力扣链接
给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。

思路1 层序遍历

层序遍历完之后统计里面的元素个数

class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        levels = []
        self.helper(root, 0, levels)
        cnt = 0
        
        for level in levels:
            for _ in level:
                cnt += 1
        return cnt
    def helper(self, node, level, levels):
        if node == None:
            return
        if len(levels)==level:
            levels.append([])
        levels[level].append(node.val)
        self.helper(node.left, level+1, levels)
        self.helper(node.right, level +1, levels)

思路2 完全二叉树

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

如何判断是否满二叉树？在完全二叉树中，如果向左遍历的深度等于向右遍历的深度，则说明为满二叉树（因为完全二叉树如果不满，则一定是右边缺了）

class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        return self.getnodenum(root)
    
    def getnodenum(self,node):
        if node == None:
            return 0
        leftnum = self.getnodenum(node.left)
        rightnum = self.getnodenum(node.right)
        treenum = 1+leftnum+rightnum
        return treenum