D17● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int val) { this.val = val; }
}

class Solution {
    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }

        int leftHeight = getHeight(root.left); // 获取左子树的高度
        int rightHeight = getHeight(root.right); // 获取右子树的高度

        if (Math.abs(leftHeight - rightHeight) > 1) {
            return false; // 左右子树高度差超过1，不是高度平衡的二叉树
        }

        // 递归判断左右子树是否都是高度平衡的
        return isBalanced(root.left) && isBalanced(root.right);
    }

    // 辅助函数，计算二叉树的高度
    private int getHeight(TreeNode node) {
        if (node == null) {
            return 0;
        }
        return Math.max(getHeight(node.left), getHeight(node.right)) + 1;
    }
}

110.平衡二叉树

当输入的二叉树为空树（即 root == null）时，直接返回 true，因为空树被认为是高度平衡的二叉树。

if (root == null) { return true; }

使用 getHeight 方法分别计算当前节点的左子树和右子树的高度，并存储在 leftHeight 和 rightHeight 变量中。

int leftHeight = getHeight(root.left); // 获取左子树的高度 int rightHeight = getHeight(root.right); // 获取右子树的高度

然后，通过比较左子树和右子树的高度差的绝对值是否大于 1，来判断当前节点是否是高度平衡的。

if (Math.abs(leftHeight - rightHeight) > 1) { return false; // 左右子树高度差超过1，不是高度平衡的二叉树 }

如果当前节点的左子树和右子树高度差没有超过 1，则继续递归判断当前节点的左子树和右子树是否都是高度平衡的，如果都是，则返回 true，表示是高度平衡的二叉树；否则，返回 false，表示不是高度平衡的二叉树。

return isBalanced(root.left) && isBalanced(root.right);

getHeight 方法是一个辅助函数，用于计算二叉树的高度。当输入的节点为空时，返回 0；否则，递归地计算左子树和右子树的高度，并返回较大的高度值加 1，表示当前节点的高度。

private int getHeight(TreeNode node) { if (node == null) { return 0; } return Math.max(getHeight(node.left), getHeight(node.right)) + 1; }

以上的实现通过递归的方式来判断二叉树是否是高度平衡的，递归地计算每个节点的左子树和右子树的高度，并比较其高度差是否超过 1，从而判断整个二叉树是否是高度平衡的。

257. 二叉树的所有路径

import java.util.ArrayList;
import java.util.List;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class BinaryTreePaths {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> paths = new ArrayList<>();
        if (root == null) {
            return paths;
        }
        StringBuilder sb = new StringBuilder();
        dfs(root, sb, paths);
        return paths;
    }

    private void dfs(TreeNode node, StringBuilder sb, List<String> paths) {
        if (node == null) {
            return;
        }
        int len = sb.length();
        sb.append(node.val);
        if (node.left == null && node.right == null) {
            // 当前节点为叶子节点，将路径加入到结果列表中
            paths.add(sb.toString());
        } else {
            // 当前节点不是叶子节点，继续递归遍历左右子树
            sb.append("->");
            dfs(node.left, sb, paths);
            dfs(node.right, sb, paths);
        }
        sb.setLength(len); // 恢复StringBuilder的长度
    }
}

这段代码实现了一个二叉树的根节点到叶子节点的路径的查找功能。主要的实现思路如下：

定义了一个TreeNode类，表示二叉树的节点，包含了节点的值、左子节点和右子节点。
实现了binaryTreePaths方法，该方法接受一个二叉树的根节点作为输入，返回一个包含所有从根节点到叶子节点的路径的字符串列表。
在binaryTreePaths方法中，首先创建了一个空的字符串列表paths，用于保存结果。
然后，创建了一个StringBuilder对象sb，用于构建路径。
调用了dfs方法，该方法是一个深度优先搜索（DFS）的递归函数，用于遍历二叉树的每一条路径。
在dfs方法中，首先判断当前节点是否为null，如果是，则返回。
如果当前节点是叶子节点（即左右子节点都为null），则将当前路径加入到结果列表paths中。
如果当前节点不是叶子节点，则将当前节点的值添加到sb中，并加入"->"符号表示节点之间的连接。
然后，递归调用dfs方法，分别遍历当前节点的左子节点和右子节点。
在回溯时，需要将sb的长度恢复，以便删除上一层节点的值，保持路径的正确性。
最终，返回结果列表paths，其中包含了所有从根节点到叶子节点的路径的字符串表示。

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        int leftValue = sumOfLeftLeaves(root.left);    // 左
        int rightValue = sumOfLeftLeaves(root.right);  // 右
                                                       
        int midValue = 0;
        if (root.left != null && root.left.left == null && root.left.right == null) { 
            midValue = root.left.val;
        }
        int sum = midValue + leftValue + rightValue;  // 中
        return sum;
    }
}