☆☆☆☆☆leetcode 110.平衡二叉树

题目链接：leetcode 110.平衡二叉树

题目分析

递归采用后序遍历，判断每个节点的左右子树高度的差值是否超过1，若发现不平衡则返回-1。

代码

1.1递归，后序遍历
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);
        int rightHeight=getHeight(root.right);
        if(leftHeight==-1)
            return -1;
        if(rightHeight==-1)
            return -1;
        if(Math.abs(leftHeight-rightHeight)>1)
            return -1;
        return Math.max(leftHeight,rightHeight)+1;
    }
}

1.2递归，后序遍历（精简版本）
    public int getHeight(TreeNode root){
        if(root==null)
            return 0;
        if(getHeight(root.left)==-1||getHeight(root.right)==-1)
            return -1;
        return Math.abs(getHeight(root.left)-getHeight(root.right))>1?-1:Math.max(getHeight(root.left),getHeight(root.right))+1;
    }
}

☆☆☆☆☆leetcode 257. 二叉树的所有路径

题目链接：leetcode 257. 二叉树的所有路径

题目分析

递归+回溯，采用前序遍历，res存最终的结果，paths作为结果中的路径，注意路径要转为String类型。

代码

1.1递归+回溯，前序遍历
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res=new ArrayList<>();
        if(root==null)
            return res;
        List<Integer> paths=new ArrayList<>();
        traversal(root,paths,res);
        return res;
    }

    public void traversal(TreeNode root,List<Integer> paths,List<String> res){
        paths.add(root.val);
        if(root.left==null&&root.right==null){
            StringBuilder sb=new StringBuilder();
            for(int i=0;i<paths.size()-1;i++)
                sb.append(paths.get(i)).append("->");
            sb.append(paths.get(paths.size()-1));
            res.add(sb.toString());
            return;
        }
        if(root.left!=null){
            traversal(root.left,paths,res);
            paths.remove(paths.size()-1);
        }
        if(root.right!=null){
            traversal(root.right,paths,res);
            paths.remove(paths.size()-1);
        }
    }
}

1.2递归+回溯，前序遍历（精简版本）
class Solution {

    List<String> res=new ArrayList<>();

    public List<String> binaryTreePaths(TreeNode root) {
        deal(root,"");
        return res;
    }

    public void deal(TreeNode node,String s){
        if(node==null)
            return;
        if(node.left==null&&node.right==null){
            res.add(new StringBuilder(s).append(node.val).toString());
            return;
        }
        String temp=new StringBuilder(s).append(node.val).append("->").toString();
        deal(node.left,temp);
        deal(node.right,temp);
    }
}

提示：StringBuilder 是 Java 中的一个可变字符序列类，提供了修改字符串内容的能力，包括追加、插入和删除等操作，且这些操作都是在原对象上进行的，不会生成新的对象，因此在进行大量字符串操作时，使用 StringBuilder 可以显著提高性能。
补充StringBuilder 的常用方法：
StringBuilder()：构造一个空的 StringBuilder
StringBuilder(CharSequence seq)：构造一个包含指定字符序列的 StringBuilder
StringBuilder(int capacity)：构造一个具有指定初始容量的 StringBuilder
append(…)：向字符序列的末尾追加指定的内容（可以是各种类型的数据，如 String、char、int 等），并返回 this 对象的引用
insert(int offset, CharSequence csq)：在指定位置插入指定的字符序列
delete(int start, int end)：删除此序列的子字符串中的字符
replace(int start, int end, String str)：用指定字符串替换此序列的子字符串
length()：返回此字符序列的长度
toString()：返回此序列中数据的字符串表示形式

☆☆☆☆☆leetcode 404.左叶子之和

题目链接：leetcode 404.左叶子之和

题目分析

采用递归后序遍历，判断一个节点是不是左叶子要看该节点的父节点，如果一个节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子。

代码

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if(root==null)
            return 0;
            int left=sumOfLeftLeaves(root.left);
            int right=sumOfLeftLeaves(root.right);
            int mid=0;
            if(root.left!=null&&root.left.left==null&&root.left.right==null){
                mid=root.left.val;
            }
            return left+mid+right;
    }
}

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

题目链接：leetcode 222.完全二叉树的节点个数

题目分析

采用递归后序遍历即可。

代码

class Solution {
    public int countNodes(TreeNode root) {
        if(root==null)
            return 0;
        return countNodes(root.left)+countNodes(root.right)+1;
    }
}