算法学习day17

110 平衡二叉树

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

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

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

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

递归

• 入参：根节点，返回当前节点的高度
• 递归终止，
  • 节点为null, return 0 ;
  • 是否时平衡二叉树，不是返回-1
• 循环条件：分别得到左右子树的高度

 public int countNodes(TreeNode root) {

        return getHeight(root) == -1 ?false:true;
    }
    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int left = getHeight(root.left);
        if(left < 0) { return -1 ;}
        int right = getHeight(root.right);
        if(right < 0) { return -1 ;}

        return Math.abs(left )- Math.abs(right) > 1 ? -1 : Math.max(left, right)+1;
    }

257. 二叉树的所有路径

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

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

示例 1：

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

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

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

递归

• 递归三部曲：入参和返回值（局部变量），终止条件，单层循环逻辑
• 入参：节点，路径、返回结果
• 终止条件：左右子节点为空，添加返回值
• 循环条件：每循环一层，递归+回溯

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

        getTreePaths(root,paths,res);
        return res ;
    }
    public void getTreePaths(TreeNode root,List<Integer> paths,List<String> res){
        //路径
        paths.add(root.val);

        //终止条件
        if(root.left == null && root.right == null){
            //将当前path添加到res中
            StringBuilder sb = new StringBuilder();
            for(int i = 0;i<paths.size()-1;i++){
                sb.append(paths.get(i));
                sb.append("->");
            }
            sb.append(paths.get(paths.size()-1));
            res.add(sb.toString());
            return ;
        }
        //单层递归逻辑
        if(root.left != null ){
            getTreePaths(root.left,paths,res);
            paths.remove(paths.size()-1);
        }
        if(root.right!= null ){
            getTreePaths(root.right,paths,res);
            paths.remove(paths.size()-1);
        }
    }

}
//leetcode submit region end(Prohibit modification and deletion)

迭代

• 参考二叉树的最大深度，利用层序遍历解决

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

递归

• 左叶子节点：左右子节点都为空，且处于父节点的左侧
• 入参:每个节点、是否时左叶子节点
• 终止条件：节点为空返回0，左右子节点为空且是左子节点是计算和
• 循环条件：所有节点

class Solution {
    int sum = 0 ;

    public int sumOfLeftLeaves(TreeNode root) {
        dfs(root,false);
        return sum;
    }
    public void dfs(TreeNode root,boolean isLeft){
        if(root == null){ return ; }

        if(root.left == null && root.right == null && isLeft){
            sum += root.val;
            return ;
        }
        dfs(root.left,true);
        dfs(root.right,false);

    }
}

总结

• 递归三部曲：参数和返回值、终止条件、单层循环逻辑
• 回溯要记录路径，一般用List记录所经过的path，回溯要和递归一起存在