二叉树-01

1. 二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

真题点击此处：104. 二叉树的最大深度

1.1 深度优先搜索

解题思路：

1. 如果根节点为空，则返回0；
2. 否则，递归计算左子树和右子树的最大深度。通过递归调用self.maxDepth(root.left)和self.maxDepth(root.right)来实现；
3. 返回左右子树最大深度的较大值加1。加1是因为需要将当前节点也计算在内。

以下为代码实现：

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0

        left = self.maxDepth(root.left)
        right = self.maxDepth(root.right)

        return max(left, right) + 1

时间复杂度：O(n)，其中 n 为二叉树节点的个数。每个节点在递归中只被遍历一次。

空间复杂度：O(height)，其中 height 表示二叉树的高度。递归函数需要栈空间，而栈空间取决于递归的深度，因此空间复杂度等价于二叉树的高度。

1.2 广度优先搜索

解题思路：

1. 首先判断根节点是否为空，如果为空则直接返回深度0；
2. 创建一个队列 queue 用来进行层序遍历，将根节点加入队列；
3. 初始化一个变量 ans 用来记录当前遍历到的层数，初始值为0；
4. 进入循环，只要队列不为空，就继续遍历：
   • 获取当前队列的大小，表示当前层的节点个数；
   • 遍历当前层的所有节点，将每个节点出队，并将其非空的子节点入队；
   • 每处理完一层节点，将 ans 自增1；
5. 当循环结束时，返回 ans，即为二叉树的最大深度。

以下为代码实现：

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int ans = 0;

        while(!queue.isEmpty()){
            int size = queue.size();
            while(size > 0){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }

                if(node.right != null){
                    queue.offer(node.right);
                }
                
                size--;
            }
            ans++;
        }
        return ans;
    }
}

时间复杂度：O(n)，其中 n 为二叉树的节点个数。与方法一同样的分析，每个节点只会被访问一次。

空间复杂度：此方法空间的消耗取决于队列存储的元素数量，其在最坏情况下会达到 O(n)。

2. 二叉树的最小深度

给定一个二叉树，找出其最小深度。

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

说明：叶子节点是指没有子节点的节点。

真题点击此处：111. 二叉树的最小深度

2.1 深度优先搜索

解题思路：

1. 首先判断根节点是否为空，如果为空则直接返回深度0；
2. 如果根节点的左右子节点都为空（即为叶子节点），则返回深度1；
3. 初始化一个变量 depth 用来记录当前节点的最小深度，初始值设为无穷大；
4. 如果左子节点不为空，则递归计算左子树的最小深度，并更新 depth 为当前 depth 和左子树深度的较小值；
5. 如果右子节点不为空，则递归计算右子树的最小深度，并更新 depth 为当前 depth 和右子树深度的较小值；
6. 返回 depth + 1，加1是因为需要将当前节点也计算在内。

以下为代码实现：

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0

        if root.left is None and root.right is None:
            return 1

        depth = inf
        if root.left:
            depth = min(depth, self.minDepth(root.left))

        if root.right:
            depth = min(depth, self.minDepth(root.right))

        return depth + 1

时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。

空间复杂度：O(H)，其中 H 是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度为 O(log⁡N)。

2.2 广度优先搜索

解题思路：

1. 定义了一个内部类 QueueNode，用于存储树节点和节点的深度信息。
2. 首先判断根节点是否为空，如果为空则直接返回深度0；
3. 创建一个队列 queue 用来进行层序遍历，将根节点和深度1的信息作为起始节点加入队列。
4. 进入循环，只要队列不为空，就继续遍历：
   • 出队一个节点及其深度信息；
   • 如果该节点为叶子节点（即左右子节点均为空），则返回当前的深度；
   • 如果左子节点不为空，则将左子节点和深度加1的信息加入队列；
   • 如果右子节点不为空，则将右子节点和深度加1的信息加入队列。
5. 循环结束后仍未找到叶子节点，则返回深度0。

以下为代码实现：

class Solution {
    class QueueNode{
        TreeNode node;
        int depth;

        public QueueNode(TreeNode node, int depth){
            this.node = node;
            this.depth = depth;
        }
    }
    public int minDepth(TreeNode root) {
        if(root==null){
            return 0;
        }

        Queue<QueueNode> queue = new LinkedList<>();
        queue.offer(new QueueNode(root, 1));
        while(!queue.isEmpty()){
            QueueNode nodeDepth = queue.poll();
            TreeNode node = nodeDepth.node;
            int depth = nodeDepth.depth;
            if(node.left == null && node.right == null){
                return depth;
            }
            if(node.left != null){
                queue.offer(new QueueNode(node.left, depth + 1));
            }
            if(node.right != null){
                queue.offer(new QueueNode(node.right, depth + 1));
            }
        }

        return 0;
    }
}

时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。

空间复杂度：O(N)，其中 N 是树的节点数。空间复杂度主要取决于队列的开销，队列中的元素个数不会超过树的节点数。

3. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

真题点击此处：112. 路径总和

3.1 深度优先搜索

解题思路：

1. 首先判断根节点是否为空，如果为空则直接返回 False；
2. 如果根节点的左右子节点都为空（即为叶子节点），则判断 targetSum 是否等于当前叶子节点的值，如果相等则返回 True，否则返回 False；
3. 递归地判断左子树和右子树中是否存在路径使得路径上所有节点值的和等于 targetSum - root.val，如果左子树或右子树中存在满足条件的路径，则返回 True。

以下为代码实现：

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root is None:
           return False

        if root.left is None and root.right is None:
            return targetSum == root.val

        return self.hasPathSum(root.left, targetSum - root.val) or self.hasPathSum(root.right, targetSum - root.val)

时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。

空间复杂度：O(H)，其中 HHH 是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度为 O(log⁡N)。

3.2 广度优先搜索

解题思路：

1. 首先判断根节点是否为空，如果为空则直接返回 False；
2. 创建两个队列 queNode 和 queVal，分别用于存储节点和节点值的和。将根节点和节点值 root.val 分别加入队列 queNode 和 queVal；
3. 进入循环，只要队列不为空，就继续遍历：
   • 出队一个节点及其节点值的和；
   • 如果该节点为叶子节点（即左右子节点均为空），则判断节点值的和是否等于目标和 targetSum，如果相等则返回 True，否则继续遍历；
   • 如果左子节点不为空，则将左子节点和节点值的和加入队列；
   • 如果右子节点不为空，则将右子节点和节点值的和加入队列。
4. 循环结束后仍未找到满足条件的路径，则返回 False。

以下为代码实现：

class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root == null){
            return false;
        }

        Queue<TreeNode> queNode = new LinkedList<>();
        Queue<Integer> queVal = new LinkedList<>();
        queNode.offer(root);
        queVal.offer(root.val);
        
        while(!queNode.isEmpty()){
            TreeNode node = queNode.poll();
            int val = queVal.poll();

            if(node.left == null && node.right == null){
                if(targetSum == val){
                    return true;
                }
                continue;
            }

            if(node.left != null){
                queNode.offer(node.left);
                queVal.offer(val + node.left.val);
            }

             if(node.right != null){
                queNode.offer(node.right);
                queVal.offer(val + node.right.val);
            }
        }  
        return false;
    }
}   

时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。

空间复杂度：O(N)，其中 N 是树的节点数。空间复杂度主要取决于队列的开销，队列中的元素个数不会超过树的节点数。