二叉树最大深度、二叉树最小深度

二叉树层序遍历

给你二叉树的根节点 root ，返回其节点值的层序遍历 。（即逐层地，从左到右访问所有节点）。
示例 1：

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

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        
        if root is None:
            return []
        
        queue = collections.deque([root])
        result = [] 
        while queue:
            level = []
            for _ in range(len(queue)): # 9， 20
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
        return result

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if (!root) return {};        // 如果根节点为空，则返回空列表
        queue<TreeNode*> que;       // 将根节点加入队列
        vector<vector<int>> result; // 存储结果的二维向量
        que.push(root);

        while(!que.empty()) {
            int size = que.size(); // 当前层节点的数量
            vector<int> level;   // 存储当前层的节点值
            for (int i = 0; i < size; ++i) {
                TreeNode* cur = que.front();
                que.pop();
                level.push_back(cur->val); // 将当前节点值加入当前层的结果
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
            result.push_back(level);
        }
        return result;
    }
};

二叉树最大深度

• 给定一个二叉树 root ，返回其最大深度。 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。 示例 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
        depth = 0
        queue = collections.deque([root])
        while queue:
            print(len(queue))
            level = []
            depth += 1
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return depth

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (!root) return 0;
        int result = 0;
        queue<TreeNode*> que;
        que.push(root);

        while(!que.empty()) {
            int size = que.size();
            result += 1;
            for (auto i=0; i < size; i++) {
                TreeNode* cur = que.front();
                que.pop();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }
        return result;
        
    }
};

# 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:
        return self.getdepath(root)
        
    # 确定递归参数和返回值    
    def getdepath(self, node):
        # 终止条件
        if not node:
            return 0
        # 单层遍历
        leftdepath = self.getdepath(node.left)
        rightdepath = self.getdepath(node.right)
        height = 1 + max(leftdepath, rightdepath)
        return height

二叉树最小深度

• 给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。 说明：叶子节点是指没有子节点的节点。
• 示例 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 minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        depth = 0
        queue = collections.deque([root])
        while queue:
            level = []
            depth += 1
            for _ in range(len(queue)):
                cur = queue.popleft()
                if not cur.left and not cur.right:
                    return depth
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return depth

class Solution {
public:
    int minDepth(TreeNode* root) {
        if (!root) return 0;
        queue<TreeNode*> que; // 定义了一个queue型的que
        que.push(root);
        int result = 0;
        
        while(!que.empty()) {
            int size = que.size();
            result += 1;
            for (auto i = 0;  i < size; i++) {
                TreeNode* cur = que.front();
                que.pop(); // 出栈
                if ((!cur->left) && (!cur->right)) {
                    return result;
                }
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }
        return result;
    }
};