Leetcode & CTCI ---Day 3

Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

 This problem is similar with maximum Depth of binary Tree. However, what's difference is that we need to check whether a node is the leaf node, else it will return 0. But in the problem of maximum depth tree, we do not need to do this, we just get as deeper as we can(get Math.max(leght)). 

 

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int minDepth(TreeNode root) {
        if (root == null)
            return 0;
        if (root.left == null)
            return minDepth(root.right) + 1;
        if (root.right == null)
            return minDepth(root.left) + 1;
        return Math.min(minDepth(root.left), minDepth(root.right))+1;
    }
}

Path Sum

Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.

For example:
Given the below binary tree and sum = 22,

              5
             / 
            4   8
           /   / 
          11  13  4
         /        
        7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

This problem cost me a while to think about, which I do not think it should be classified as easy level. 

My first mind solution is a little trick as below:

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null)
            return false;
        return hasPathSum(root, sum, 0);
    }
    
    public boolean hasPathSum(TreeNode root, int sum, int currentSum){

        currentSum += root.val;
        if (root.left == null && root.right == null){
            if (currentSum == sum)
                return true;
            else
                return false;
        }
        if (root.left != null){
            if (hasPathSum(root.left, sum, currentSum))
                return true;
        }
        if (root.right != null){
            if (hasPathSum(root.right, sum, currentSum))
                return true;
        }
        return false;
    }
}

Later when I check other's answer, I found this more convience and clean code, althought the coding idea is the same as mine.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null)
            return false;
        return hasPathSum(root, sum, 0);
    }
    
    public boolean hasPathSum(TreeNode root, int sum, int currentSum){
        if (root == null)
            return false;
        currentSum += root.val;
        if (root.left == null && root.right == null){
            if (currentSum == sum)
                return true;
            else
                return false;
        }
        return hasPathSum(root.left, sum, currentSum) || hasPathSum(root.right, sum, currentSum);
    }
}

Question 3

Minimum Depth of Binary Tree

 Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

 This problem is done before with DFS function. Here I used BFS to do it again. For BFS, remember to use a queue to keep all nodes' siblings.

public class Solution {
    public int minDepth(TreeNode root) {
        if (root == null)
            return 0;
        int depth = 1;
        ArrayList<TreeNode> queue = new ArrayList<TreeNode>();
        queue.add(root);
        int curnum = 1;
        int nextnum = 0;
        while (!queue.isEmpth()){
            TreeNode cur = queue.poll();
            curnum--;
            if (cur.left == null && cur.right == null)
                return depth;
            if (cur.left != null){
                queue.add(cur.left);
                nextNum ++;
            }
            if (cur.right != null){
                queue.add(cur.right);
                nextnum ++;
            }
            if (curnum == 0){
                curnum = nextnum;
                nextnum = 0;
                depth++;
            }
        }
        return depth;
    }
}