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

解法一：

up - down 自顶向下，检查是否为平衡BST

The first method checks whether the tree is balanced strictly according to the definition of balanced binary tree: the difference between the heights of the two sub trees are not bigger than 1, and both the left sub tree and right sub tree are also balanced. With the helper function depth().  第一种方法检查是否平衡严格按照平衡二叉树的定义，左右子树的高度差不超过1，左右子树也是平衡树

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int depth(TreeNode* root)
    {
        if(root == NULL)
            return 0;
        return 1 + max(depth(root->left),depth(root->right));
    }
    bool isBalanced(TreeNode* root) {
        if(root == NULL)
            return true;
        int left = depth(root->left);
        int right = depth(root->right);
        
        return (abs(left-right) <= 1) && isBalanced(root->left) && isBalanced(root->right);
    }
};

解法二：采用DFS

The second method is based on DFS. Instead of calling depth() explicitly for each child node, we return the height of the current node in DFS recursion. When the sub tree of the current node (inclusive) is balanced, the function dfsHeight() returns a non-negative value as the height. Otherwise -1 is returned. According to the leftHeight and rightHeight of the two children, the parent node could check if the sub tree is balanced, and decides its return value. 我们不再返回每个节点的高度，而是在DFS中返回当前节点左右子树的高度，如果当前节点是平衡的，函数返回非负的高度值，否则返回-1。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int DFSTree(TreeNode* root)
    {
        if(root == NULL)
            return 0;
        int leftH = DFSTree(root->left);
        if(leftH == -1)
            return -1;
        int rightH = DFSTree(root->right);
        if(rightH == -1)
            return -1;
        if(abs(leftH - rightH) > 1)
            return -1;
        return max(leftH,rightH) + 1;
    }
    bool isBalanced(TreeNode* root) {
        return DFSTree(root) != -1;
    }
};