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

104.二叉树的最大深度 maximum-depth-of-binary-tree

递归 - 前后序

本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。

前序中序还是后序取决于在哪里进行操作

self.traverse(root.left)

self.traverse(root.right)

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

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

后序：

int leftdepth = getdepth(node->left);       // 左
int rightdepth = getdepth(node->right);     // 右
int depth = 1 + max(leftdepth, rightdepth); // 中
return depth;

迭代

    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        
        depth = 0
        queue = collections.deque([root])
        
        while queue:
            depth += 1
            for _ in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        
        return depth

559.n叉树的最大深度

一样的套路，但是不止left/right，而是loop child

class Solution:
    def maxDepth(self, root: 'Node') -> int:
        if not root:
            return 0
        queue = collections.deque([root])
        depth = 0
        
        while queue:
            size = len(queue)
            depth += 1
            for _ in range(size):
                node = queue.popleft()
                for child in node.children:
                    queue.append(child)
        return depth

111.二叉树的最小深度

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

from queue import Queue
class Solution:
    
    def minDepth(self, root: Optional[TreeNode]) -> int:  
        if not root:
            return 0
        q = Queue()
        q.put(root)
        # root 本身就是一层，depth 初始化为 1
        depth = 1

        while not q.empty(): 
            sz = q.qsize()
            # 将当前队列中的所有节点向四周扩散
            for i in range(sz):
                cur = q.get()
                # 判断是否到达终点
                if not cur.left and not cur.right:
                    return depth
                # 将 cur 的相邻节点加入队列
                if cur.left:
                    q.put(cur.left)
                if cur.right:
                    q.put(cur.right)
            # 这里增加步数
            depth += 1
        
        return depth

 222.完全二叉树的节点个数（优先掌握递归）

在子节点处res += 1

class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        queue = collections.deque()
        if root:
            queue.append(root)
        result = 0
        while queue:
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                result += 1 #记录节点数量
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return result