LeetCode #10（#110、#111、#112）

110. Balanced Binary Tree

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as:

a binary tree in which the left and right subtrees of every node differ in height by no more than 1.

Example 1:

Given the following tree [3,9,20,null,null,15,7]:

   3
  / \
 9  20
   /  \
  15   7

Return true.

Example 2:

Given the following tree [1,2,2,3,3,null,null,4,4]:

      1
     / \
    2   2
   / \
  3   3
 / \
4   4

Return false.

//Solution
//总结：DFS
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int depth(struct TreeNode* root) {
    if (!root) return 0;
    
    int l = depth(root->left);
    if (l < 0) return -1;
    
    int r = depth(root->right);
    if (r < 0) return -1;
    
    int mx = l;
    int mn = r;
    
    if (l < r) {
        mx = r;
        mn = l;
    }
    
    if (mx - mn > 1) return -1;
    
    return mx + 1;
}

bool isBalanced(struct TreeNode* root){
    return depth(root) != -1;
}

111. 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.

Note: A leaf is a node with no children.

Example:

Given binary tree [3,9,20,null,null,15,7],

   3
  / \
 9  20
   /  \
  15   7

return its minimum depth = 2.

//Solution
//总结：分别求出左右两端即可
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int minDepth(struct TreeNode* root){
    if(!root) return 0;
    if(!root->left && !root->right) return 1;
    int lDepth, rDepth;
    if(root->left)
        lDepth = minDepth(root->left)+1;
    if(root->right)
        rDepth = minDepth(root->right)+1;
    if(lDepth>rDepth) return rDepth;
    else return lDepth;
}

112. 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.

Note: A leaf is a node with no children.

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.

//Solution
//总结：
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool hasPathSum(struct TreeNode* root, int sum){
    if(root == NULL)return false;
    if(root->left == NULL && root->right == NULL && sum - root->val== 0)return true;
    bool ans = hasPathSum(root->left,sum - root->val);
    ans = ans || hasPathSum(root->right,sum - root->val);
    return ans;
}