代码随想录算法训练营第十六天|110.平衡二叉树 （优先掌握递归） 257. 二叉树的所有路径 （优先掌握递归） 404.左叶子之和 （优先掌握递归）

110.平衡二叉树 （优先掌握递归）

public boolean isBalanced(TreeNode root) {
    if (root == null) {
        return true;
    }
    boolean[] flag = {true};
    int i = preOrder(root, flag);
    return flag[0];

}

public int preOrder(TreeNode root, boolean[] flag) {
    if (root == null) {
        return 0;
    }
    int leftHeight = preOrder(root.left, flag);
    int rightHeight = preOrder(root.right, flag);
    int much = leftHeight - rightHeight;

    if (much > 1 || much < -1) {
        flag[0] = false;

    }
    return Math.max(rightHeight, leftHeight) + 1;
}

257. 二叉树的所有路径 （优先掌握递归）

public List<String> binaryTreePaths(TreeNode root) {
    List<String> res = new ArrayList<>();
    List<List<String>> ans = new ArrayList<>();
    dfs(root, res, ans);
    List<String> result = new ArrayList<>();
    for (List<String> an : ans) {
        String path = "";
        for (int i = 0; i < an.size(); i++) {
            if (i == an.size() - 1) {
                path = path.concat(an.get(i));
            } else {
                path = path.concat(an.get(i)).concat("->");
            }
        }
        result.add(path);
    }

    return result;
}

public void dfs(TreeNode root, List<String> path, List<List<String>> ans) {
    if (root == null) {
        return;
    }

    path.add(new Integer(root.val).toString());

    if (root.left == null && root.right == null) {
        ArrayList res = new ArrayList(path);
        ans.add(res);
    }

    dfs(root.left, path, ans);
    dfs(root.right, path, ans);

    path.remove(path.size() - 1);


}

104.左叶子之和 （优先掌握递归）

public int sumOfLeftLeaves(TreeNode root) {
    int[] sum = new int[1];
    Boolean[] flag = new Boolean[1];
    flag[0] = false;
    preOrder(root, sum, flag);
    return sum[0];

}

public void preOrder(TreeNode root, int[] sum, Boolean[] flag) {
    if (root == null) {
        return;
    }
    if (root.left == null && root.right == null && flag[0]) {
        sum[0] += root.val;
    }
    flag[0] = true;
    preOrder(root.left, sum, flag);
    flag[0] = false;
    preOrder(root.right, sum, flag);
}