zoukankan      html  css  js  c++  java
  • 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;
        }
    }
  • 相关阅读:
    new Date在不同浏览器识别问题
    22. Generate Parentheses dfs填表
    迪杰斯特拉+优先队列实现
    1062 最简分数 (20 分)
    1091 N-自守数 (15 分)
    1054 求平均值 (20 分)
    1045 快速排序 (25 分)
    1086 就不告诉你 (15 分)
    1076 Wifi密码 (15 分)
    1081 检查密码 (15 分)
  • 原文地址:https://www.cnblogs.com/timoBlog/p/4641677.html
Copyright © 2011-2022 走看看