LeetCode: Balanced Binary Tree

C++

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int dfs(TreeNode *root, bool &flag, int cur) {
        if (!root || !flag) return cur;
        int leftH = dfs(root->left, flag, cur+1);
        if (!flag) return cur;
        int rightH = dfs(root->right, flag, cur+1);
        if (abs(leftH-rightH) <= 1 && flag) flag = true;
        else flag = false;
        return max(leftH, rightH);
    }
    bool isBalanced(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (!root) return true;
        bool flag = true;
        if (abs(dfs(root->left, flag, 0)-dfs(root->right, flag, 0)) <= 1 && flag) return true;
        else return false;
    }
};

Java: Time complexity: O(N), Space complexity: O(LOGN)

/**
 * 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 isBalanced(TreeNode root) {
        return checkHeight(root) != -1;
    }
    private int checkHeight(TreeNode root)
    {
        if (root == null)
        {
            return 0;
        }
        int leftHeight = checkHeight(root.left);
        if (leftHeight == -1)
        {
            return -1;
        }
        int rightHeight = checkHeight(root.right);
        if (rightHeight == -1)
        {
            return -1;
        }
        int heightDiff = Math.abs(leftHeight - rightHeight);
        if (heightDiff > 1)
        {
            return -1;
        }
        else
        {
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }
}