代码随想录训练营第十七天 | 110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和

110.平衡二叉树

该题首先弄清楚两个二叉树概念：

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

该题需要判断每个节点的左右子树高度差绝对值不超过1

所以我们就去求每个以每个节点为根节点的二叉树的左右子树高度差

1.求左右子树分别的最大高度

2.求最大高度差绝对值进行判断

3.注：由于二叉树节点高度是由该节点到叶子节点的路径，所以需要用后序遍历方式在已经得到左右子树最大高度后再进行运算

代码如下：

class Solution {
    public boolean isBalanced(TreeNode root) {
        getMaxDepth(root);
        return isBalanced;
    }
    
    // 记录二叉树是否平衡
    boolean isBalanced = true;

    // 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数
    // 输入一个节点，返回以该节点为根节点的二叉树的最大高度
    public int getMaxDepth(TreeNode root){
        if(root == null){
            return 0;
        }
        // 旨在不为二叉平衡树时提前结束递归，返回值随便
        if(isBalanced == false){
            return -1;
        }

        int leftDepth = getMaxDepth(root.left);
        int rightDepth = getMaxDepth(root.right);
        // 后序遍历位置
        // 判断左右子树最大高度差的绝对值是否大于1
        if(Math.abs(rightDepth - leftDepth) > 1){
            isBalanced = false;
        }
        return 1 + Math.max(leftDepth, rightDepth);
    }
}

 257. 二叉树的所有路径

该题目就是遍历二叉树，然后将符合条件的路径输出

只不过需要注意：为了防止获得重复路径值，需要利用回溯思想，保证元素单一性

代码如下：

class Solution {
    List<String> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        traverse(root);
        return res;
    }

    public void traverse(TreeNode root){
        if(root == null){
            return;
        }
        // 前序遍历位置进行树节点值添加
        path.add(root.val);
        // 如果遍历完一条路径
        if(root.left == null && root.right == null){
            StringBuilder sb = new StringBuilder();
            for(int i = 0;i<path.size() - 1;i++){
                System.out.println(path.get(i));
                sb.append(path.get(i)).append("->"); // 添加方式"1->" + "2->"....
            }
            // 此时所处状态 "1->2->",所以在添加列表中最后一个元素
            sb.append(path.get(path.size() - 1));
            res.add(sb.toString());
        }else{
            traverse(root.left);
            traverse(root.right);
        }
        // 后序遍历位置移出最后一个添加的树节点值，回溯
        path.remove(path.size() - 1);
    }
}

404.左叶子之和

【遍历】思维

该题由于要寻找左叶子节点的值，所以可以遍历一遍二叉树获得左叶子节点值然后累加得到答案

代码如下：

class Solution {

    public int sumOfLeftLeaves(TreeNode root) {
        traverse(root);
        return sum;
    }

    // 记录左叶子之和
    int sum = 0;
    // 二叉树遍历函数
    void traverse(TreeNode root) {
        if (root == null) {
            return;
        }

        if (root.left != null &&
            root.left.left == null && root.left.right == null) {
            // 找到左侧的叶子节点，记录累加值
            sum += root.left.val;
        }

        // 递归框架
        traverse(root.left);
        traverse(root.right);
    }
}

【分解问题】思维

代码如下：

class Solution {
    // 输入一个节点，返回以该节点为二叉树的左叶子之和
    public int sumOfLeftLeaves(TreeNode root) {
        int leftValue = 0;
        // 防止在调用sumOfLeftLeaves方法时传入了空节点作为参数，出现空指针异常
        if(root == null){
            return 0;
        }
        if(root.left == null && root.right == null){
            return 0;
        }

        int leftSum = sumOfLeftLeaves(root.left);
        int rightSum = sumOfLeftLeaves(root.right);
        
        if(root.left != null && root.left.left == null && root.left.right == null){
            leftValue = root.left.val;
        }
        // 它计算左子树和右子树中左叶子节点的总和，并在左孩子节点是左叶子节点时将其值加入总和中
        int res = leftSum + rightSum + leftValue;
        return res;
    }
}