代码随想录算法训练营第15天| LeetCode110.平衡二叉树| 257. 二叉树的所有路径 | 404.左叶子之和 | 222.完全二叉树的节点个数

目录

题目链接：110. 平衡二叉树 - 力扣（LeetCode）

题目链接：257. 二叉树的所有路径 - 力扣（LeetCode）

题目链接：404. 左叶子之和 - 力扣（LeetCode）

题目链接：222. 完全二叉树的节点个数 - 力扣（LeetCode）

---

   “曾以为走不出去的日子，现在都回不去了。”  

题目链接：110. 平衡二叉树 - 力扣（LeetCode）

使用递归函数返回树的高度，同时检查每个节点是否平衡。

class Solution110 {
    public boolean isBalanced(TreeNode root) {
        return getHeight(root) != -1;
    }


    // 递归函数，返回树的高度，如果树不平衡返回-1
    private int getHeight(TreeNode node){
        if(node == null) {
            return 0;  // 空树高度为0，且认为是平衡的
        }

        int leftHeight = getHeight(node.left);
        if (leftHeight == -1)
            return -1;  // 如果左子树不平衡，则整棵树也不平衡

        int rightHeight = getHeight(node.right);
        if (rightHeight == -1)
            return -1;  // 如果右子树不平衡，则整棵树也不平衡

        if (Math.abs(leftHeight - rightHeight) > 1) {
            return -1;  // 如果当前节点的左右子树高度差超过1，则不平衡
        }

        return Math.max(leftHeight, rightHeight) + 1;  // 返回当前节点为根的树的高度
    }
}

题目链接：257. 二叉树的所有路径 - 力扣（LeetCode）

找到从根节点到所有叶子节点的路径。使用递归，核心思想是：沿着树向下遍历，一旦到达叶子节点，就将当前路径添加到结果列表中。

class Solution257 {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> paths = new ArrayList<>();  // 存储所有路径的列表
        if (root != null){
            dfs(root,"", paths);
        }

        return paths;
    }

    // 递归函数，进行深度优先搜索
    private void dfs(TreeNode node, String path, List<String> paths){
        //  到达叶子节点，将路径加入结果集中
        if (node.left == null && node.right == null) {
            paths.add(path + node.val);
        }
        // 如果有左子节点，继续搜索左子树
        if (node.left != null){
            dfs(node.left, path + node.val + "->", paths);
        }
        // 如果有右子节点，继续搜索右子树
        if (node.right != null){
            dfs(node.right, path + node.val + "->", paths);
        }

    }
}

题目链接：404. 左叶子之和 - 力扣（LeetCode）

要计算所有左叶子节点的和，在递归遍历过程中，需要判断每个节点的左子节点是否为叶子节点，如果是叶子节点，则将其值累加到结果中。

class Solution404 {
    // 主方法，返回所有左叶子节点的和
    public int sumOfLeftLeaves(TreeNode root) {
        return sumOfLeftLeavesHelper(root, false); 
    }

    // 递归函数，计算左叶子节点的和
    private int sumOfLeftLeavesHelper(TreeNode node, boolean isLeft) {
        if (node == null) {
            return 0; // 空节点返回0
        }

        if (node.left == null && node.right == null && isLeft) {
            return node.val; // 当前节点是左叶子节点，返回其值
        }

        // 递归计算左子树和右子树的左叶子节点和
        int leftSum = sumOfLeftLeavesHelper(node.left, true);
        int rightSum = sumOfLeftLeavesHelper(node.right, false);

        return leftSum + rightSum; // 返回左子树和右子树左叶子节点和的总和
    }
}

题目链接：222. 完全二叉树的节点个数 - 力扣（LeetCode）

要计算完全二叉树的节点数，可以利用完全二叉树的特性来实现一个高效的算法。由于完全二叉树的特殊结构，可以通过计算树的高度（左子树的高度）来快速确定节点数。

class Solution222 {
    public int countNodes(TreeNode root) {
        if (root == null) {
            return 0; // 空树节点数为0
        }

        int leftDepth = getDepth(root.left); // 获取左子树的深度
        int rightDepth = getDepth(root.right); // 获取右子树的深度

        if (leftDepth == rightDepth) {
            // 左子树深度等于右子树深度，说明左子树是满的，右子树可能不满
            return (int)Math.pow(2, leftDepth) + countNodes(root.right); // 2^leftDepth + 右子树的节点数
        }else {
            // 左子树深度不等于右子树深度，说明右子树是满的，左子树可能不满
            return (int)Math.pow(2, rightDepth) + countNodes(root.left); // 2^rightDepth + 左子树的节点数
        }
    }

    // 计算树的深度
    private int getDepth(TreeNode node) {
        int depth = 0;
        while (node != null){
            depth++;
            node = node.left;  // 完全二叉树的深度可以通过不断向左子树遍历来获取
        }
        return depth;
    }
}