代码随想录算法day15| 二叉树 part03||110.平衡二叉树,257. 二叉树的所有路径,404.左叶子之和,222.完全二叉树的节点个数

时间比较紧张，只够顺一下递归方法，周末补一下迭代法

110.平衡二叉树

错误代码

/**
 * 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) {
        int result=getdepth(root);
        if (result==-1) return false;
        else return true;


    }
    public int getdepth(TreeNode root){
        int depth=0;
        if(root==null) return 0;
        int left_depth=getdepth(root.left);
        int right_depth=getdepth(root.right);
        depth=Math.max(left_depth,right_depth)+1;
        if (Math.abs(right_depth-left_depth)>1){
            return -1;
        }
        return depth;
    }
}

有时候确实只沉溺于一次循环，没有考虑全面。可以先考虑简单情况，写出循环逻辑，再考虑极端情况，补充if，while判断

/**
 * 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) {
        int result=getdepth(root);
        if (result==-1) return false;
        else return true;


    }
    public int getdepth(TreeNode root){
        int depth=0;
        if(root==null) return 0;
        int left_depth=getdepth(root.left);
        if (left_depth==-1) return -1;
        int right_depth=getdepth(root.right);
        if (right_depth==-1) return -1;
        depth=Math.max(left_depth,right_depth)+1;
        if (Math.abs(right_depth-left_depth)>1){
            return -1;
        }
        return depth;
    }
}

257. 二叉树的所有路径

/**
 * 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> result=new ArrayList<>();
        List<Integer> tmp=new ArrayList<>();
        if(root==null) return result;
        getPaths(root,result,tmp);
        return result;
    }
    public void getPaths(TreeNode root,List<String> result,List<Integer> tmp){
        
        tmp.add(root.val);
        if(root.left==null&&root.right==null){
            StringBuilder sb=new StringBuilder();
            for (int i = 0; i < tmp.size() - 1; i++) {
                sb.append(tmp.get(i)).append("->");
            }
            sb.append(tmp.get(tmp.size() - 1));
            result.add(sb.toString());
            return;
        }
        if (root.left!=null) {
            getPaths(root.left,result,tmp);
            tmp.remove(tmp.size()-1);

            }
        if(root.right!=null) {
            getPaths(root.right,result,tmp);
            tmp.remove(tmp.size()-1);
            }
    }
}

404.左叶子之和

/**
 * 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;
        int sum=0;

        if(root.left==null&&root.right.left==null) return 0;
        if (root.left.left==null&&root.left.right==null) sum=root.left.val;
        int sum_leftleaves=sumOfLeftLeaves(root.left);
        
        int sum_rightleaves=0;
        if(root.right!=null){sum_rightleaves=sumOfLeftLeaves(root.right);}
        sum+=sum_leftleaves+sum_rightleaves;
        return sum;

    }
}

剪枝没剪明白

这个终止条件过不去

/**
 * 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;
        int sum=0;
        if (root.left!=null&&root.left.left==null&&root.left.right==null) sum=root.left.val;
        int sum_leftleaves=sumOfLeftLeaves(root.left);
        
        int sum_rightleaves=0;
        if(root.right!=null){sum_rightleaves=sumOfLeftLeaves(root.right);}
        sum+=sum_leftleaves+sum_rightleaves;
        return sum;

    }
}

222.完全二叉树的节点个数

/**
 * 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 countNodes(TreeNode root) {
        if (root == null) return 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        int leftDepth = 0, rightDepth = 0;
        int depgthTotal=0;
        while(left!=null){
            leftDepth+=1;
            left=left.left;
        }
        while(right!=null){
            rightDepth+=1;
            right=right.right;
        }
        if(leftDepth==rightDepth) depgthTotal=(2 << leftDepth) - 1;
        else{
            depgthTotal=countNodes(root.left) + countNodes(root.right) + 1;
        }
        return depgthTotal;

    }
}