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

LeetCode [110. 平衡二叉树]

题目：给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：

输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：

输入：root = []
输出：true

提示：

• 树中的节点数在范围 [0, 5000] 内
• -104 <= Node.val <= 104

思路：

//递归法
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        return getHeight(root) != -1;
    }
    public int getHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        int leftHeight = getHeight(root.left);
        if(leftHeight == -1){
            return -1;
        }
        int rightHeight = getHeight(root.right);
        if(rightHeight == -1){
            return -1;
        }
        if(Math.abs(rightHeight - leftHeight) > 1){
            return -1;
        }
        return Math.max(rightHeight,leftHeight) + 1;
    }
}

---

LeetCode [257. 二叉树的所有路径]

题目：给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

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

示例 1：

输入：root = [1,2,3,null,5]
输出：["1->2->5","1->3"]

示例 2：

输入：root = [1]
输出：["1"]

提示：

• 树中节点的数目在范围 [1, 100] 内
• -100 <= Node.val <= 100

思路：

//用的是前序遍历，中->左->右
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        //存储所有路径的集合
        List<String> res = new ArrayList<>();
        //存储每个路径的点集
        List<Integer> path = new ArrayList<>();
        if(root == null){
            return res;
        }
        traversal(root,path,res);
        return res;
    }
    public void traversal(TreeNode root,List<Integer> path,List<String> res){
        // 中写在这里，因为最后一个节点也要加入到path中
        path.add(root.val);
        //遇到叶子结点
        if(root.left == null && root.right == null){
            //将path里记录的路径转为String格式
            StringBuilder sb = new StringBuilder();
            for(int i = 0;i < path.size() - 1;i++){
                sb.append(path.get(i)).append("->");
            }
            //记录最后一个节点（叶子节点）
            sb.append(path.get(path.size() - 1));
            //收集一个路径
            res.add(sb.toString());
        }
        //左边
        if(root.left != null){
            traversal(root.left,path,res);
            path.remove(path.size() - 1);
        }
        //右边
        if(root.right != null){
            traversal(root.right,path,res);
            path.remove(path.size() - 1);
        }
    }
}

---

LeetCode [404. 左叶子之和]

题目：给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2:

输入: root = [1]
输出: 0

提示:

• 节点数在 [1, 1000] 范围内
• -1000 <= Node.val <= 1000

思路：

//平时已经习惯了通过节点的左右孩子判断本节点的属性，而本题要通过节点的父节点判断本节点的属性。
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        //如果当前节点为空，其左叶子节点之和为0
        if(root == null){
            return 0;
        }
        //如果当前是叶子节点，还无法判断该叶子节点是否为我们所需要的数值，因为当前节点收集的是左子树的和与右子树和
        //两个和相加即是以当前节点为根节点所统计的这个二叉树的左叶子之和
        //所以当前节点是叶子节点的时候，当前节点收集的是左子树的和与右子树和是0
        if(root.left == null &&root.right == null){
            return 0;
        }
        //左子树中符合条件的所有和
        int leftValue = sumOfLeftLeaves(root.left);
        if(root.left != null && root.left.left == null && root.left.right == null){
            leftValue = root.left.val;
        }
        //右子树中符合条件的所有和
        int rightValue = sumOfLeftLeaves(root.right);
        //中
        int sum = leftValue + rightValue;
        return sum;
    }
}