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

104.二叉树的最大深度

题目链接：二叉树的最大深度
文档讲解：代码随想录
状态：so easy

思路：左子树和右子树中取最大深度，依次往下递归

递归解法：

    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        } else {
            return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
        }
    }

迭代解法：

public int bfs(TreeNode root) {
    // 初始化深度为0
    int depth = 0;

    // 使用双端队列Deque来实现BFS
    Deque<TreeNode> deque = new LinkedList<>();

    // 如果根节点为空，则直接返回深度0
    if (root == null) {
        return depth;
    }

    // 将根节点添加到队列的末尾
    deque.addLast(root);

    // 当队列不为空时，继续遍历
    while (!deque.isEmpty()) {
        // 获取当前层的节点数量
        int size = deque.size();

        // 每处理一层，深度加1
        depth++;

        // 遍历当前层的所有节点
        while (size-- > 0) {
            // 从队列的头部移除一个节点
            TreeNode node = deque.pollFirst();

            // 如果左子节点不为空，将其添加到队列的末尾
            if (node.left != null) {
                deque.addLast(node.left);
            }

            // 如果右子节点不为空，将其添加到队列的末尾
            if (node.right != null) {
                deque.addLast(node.right);
            }
        }
    }

    // 返回计算得到的最大深度
    return depth;
}

111.二叉树的最小深度

题目链接：111.二叉树的最小深度
文档讲解：代码随想录
状态：没做出来

思路：和最大深度不同的是，在求最小深度时，需要特别处理那些只有一个子树为空的节点。如果直接使用 Math.min，会错误地计算那些没有左右子树同时存在的路径。

递归解法：

    public int minDepth(TreeNode root) {
        // 如果根节点为空，树的最小深度为0
        if (root == null) {
            return 0;
        }

        // 如果左子树为空，则最小深度为右子树的最小深度加1
        if (root.left == null) {
            return minDepth(root.right) + 1;
        }

        // 如果右子树为空，则最小深度为左子树的最小深度加1
        if (root.right == null) {
            return minDepth(root.left) + 1;
        }

        // 如果左右子树都不为空，取左右子树中较小的深度加1
        return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
    }

迭代解法：

    public int bfs(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int depth = 0;
        Deque<TreeNode> deque = new LinkedList<>();
        deque.addLast(root);
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size-- > 0) {
                TreeNode node = deque.pollFirst();
                depth++;
                if (node.left != null) {
                    deque.addLast(node.left);
                }
                if (node.right != null) {
                    deque.addLast(node.right);
                }
                // 如果当前节点是叶子节点，返回当前深度
                if (node.left == null && node.right == null) {
                    return depth;
                }
            }

        }
        return depth;
    }

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

题目链接：222.完全二叉树的节点个数
文档讲解：代码随想录
状态：还行

递归解法：

public int countNodes(TreeNode root) {
        // 如果根节点为空，节点总数为0
        if (root == null) {
            return 0;
        }

        // 如果只有左子树，则计算左子树的节点总数加上当前节点1个. 这段代码也可以不加,因为右子树不存在countNodes(root.right)会返回0
//        if (root.left != null && root.right == null) {
//            return countNodes(root.left) + 1;
//        }

        // 计算左右子树的节点总数，并加上当前节点1个
        return countNodes(root.left) + countNodes(root.right) + 1;
}

迭代解法：计数就行

public int countNodes(TreeNode root) {
        Deque<TreeNode> deque = new LinkedList<>();
        int i = 0;
        if (root != null) {
            deque.addLast(root);
            i++;
        }
        while (!deque.isEmpty()) {
            int size = deque.size();
            while (size > 0) {
                TreeNode node = deque.pollFirst();
                i++;
                if (node.left != null) {
                    deque.addLast(node.left);
                }
                if (node.right != null) {
                    deque.addLast(node.right);
                }
                size--;
            }
        }
        return i;
    }