算法day17 | 二叉树：平衡二叉树判断、二叉树所有路径、左叶子节点和

1. 110. 平衡二叉树判断

1.1 链接

https://leetcode.cn/problems/balanced-binary-tree

1.2 关键知识点

• 求二叉树深度 和 二叉树高度的差异
• 了解判断平衡树的过程实际上是遍历每个节点左右子树高度的过程，为后序遍历

1.3 自己遇到的细节问题

• 由于需要递归计算高度，因此原来的函数无法直接写递归（类型是boolean）,新建一个函数来
• 不经常想到用三元表达式使得代码更简洁

1.4 题解

/**
 * 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 ? true : false;
    }
    //后序遍历获取高度  求深度适合用前序遍历，而求高度适合用后序遍历
    public int getHeight(TreeNode root){
        if(root == null){ return 0;}

        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);

        if(leftHeight == -1 || rightHeight == -1){
            return -1;
        }else if(Math.abs(leftHeight - rightHeight) > 1){//绝对值方法
            return -1;
        }else{
            return 1 + Math.max(leftHeight, rightHeight);
        }
    }
}

2.二叉树的所有路径：回溯

2.1 链接

https://leetcode.cn/problems/binary-tree-paths

2.2 关键知识点

• 注意单层逻辑与之前最大最小深度不同的是，不是到节点为null停止，而是节点为叶子节点时就返回这一条路径的值到list中——这类停止条件，主要看通过节点的父节点的信息来辅助，如果需要就是在叶子节点的父节点就return
• 由于遍历完左子树还要遍历右子树，因此path（当前节点上面路径）一定不能被更新，pop回溯或者创建临时变量来解决

2.3 自己遇到的细节问题

• list都是add，Sb是append
• StringBuilder的append\tostring
• 创建： String tmp = new StringBuilder(s)

2.4 题解

/**
 * 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 {
    List<String> rs = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        allPath(root, "");
        return rs;
    }

    //参数为 当前节点下一节点 和 当前节点及到上面的路径，这里每次
    public void allPath(TreeNode node, String path){
        //终止条件:为叶子节点
        if(node.left == null && node.right == null){
            rs.add(new StringBuilder(path).append(node.val).toString());//需要转为String
        }

        //单层逻辑:由于是需要回溯，因此当前是建立一个临时变量而不是更新path
        if(node.left != null){
            allPath(node.left,new StringBuilder(path).append(node.val).append("->").toString());
        }
        if(node.right != null){
            allPath(node.right,new StringBuilder(path).append(node.val).append("->").toString());
        }
    }
}

3.左叶子之和：递归法练习

3.1 链接

https://leetcode.cn/problems/sum-of-left-leaves

3.2 关键知识点

• 后序遍历（左右中），需要获取左右子树结果
• 终止条件：为叶子节点或root为空
• 递归逻辑：结果为左树叶子节点值+右数叶子节点和,如果左树存在且是左叶子节点，左树值替代

3.3 自己遇到的细节问题

• 对于节点为null的情况判断要细心认真
• 开始第一次没有想出来递归逻辑。现在看这样的后序遍历解决的问题很多，本质是需要获得一个全局的结果，分解为左数结果与右树结果

3.4 题解

/**
 * 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) {
        if(root == null){return 0;}//处理root为空的情况
        if(root.left == null && root.right == null){ return 0;}//叶子节点终止

        //左树叶子节点值，右数叶子节点和,如果左树存在且是左叶子节点，左数值替代
        int leftNum = sumOfLeftLeaves(root.left);
        int rightNum = sumOfLeftLeaves(root.right);
        if(root.left != null && root.left.left == null && root.left.right == null){ 
            leftNum = root.left.val;
        }

        int sum = leftNum + rightNum;
        return sum;
    }
}

今天是生日~也希望24岁的自己可以坚持学习，努力自律，找到一份满意的工作，顺利毕业^ ^