1.Minimum Depth of Binary Tree
// 递归版,时间复杂度O(n),空间复杂度O(logn)
private static int minDepth(TreeNode root) {
if (root == null) return 0;
return Math.min(minDepth(root.left), minDepth(root.right))+1;
}
2.Maximum Depth of Binary Tree
同上,递归版,// 时间复杂度O(n),空间复杂度O(logn)
public int maxDepth(TreeNode root) {
if (root == null) return 0;
return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
3.Path Sum
return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22
// 时间复杂度O(n),空间复杂度O(logn)
public boolean hasPathSum(TreeNode root, int sum) {
if (root == null) return false;
if (root.left == null && root.right == null) // leaf
return sum == root.val;
return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
}
4.Path Sum II
同上,返回路径 // 时间复杂度O(n),空间复杂度O(logn)
public List<List<Integer>> pathSum(TreeNode root, int sum) {
List<List<Integer>> result = new ArrayList<>();
ArrayList<Integer> cur = new ArrayList<>(); // 中间结果
pathSum(root, sum, cur, result);
return result;
}
private static void pathSum(TreeNode root, int gap, ArrayList<Integer> cur, List<List<Integer>> result) {
if (root == null) return;
cur.add(root.val);
if (root.left == null && root.right == null) {
if (gap == root.val) { result.add(new ArrayList<>(cur)); }
}
pathSum(root.left, gap - root.val, cur, result);
pathSum(root.right, gap - root.val, cur, result);
cur.remove(cur.size() - 1); //添加的删除了
}
5.Binary Tree Maximum Path Sum
// 时间复杂度O(n),空间复杂度O(logn)
private int max_sum;
private int dfs(TreeNode root) {
if (root == null) return 0;
int l = dfs(root.left);
int r = dfs(root.right);
int sum = root.val;
if (l > 0) sum += l;
if (r > 0) sum += r;
max_sum = Math.max(sum, max_sum);
return Math.max(l, r) > 0 ? Math.max(l, r) + root.val : root.val;
}