leetcode[110] Balanced Binary Tree

/**
 * 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 heightTree(TreeNode *root)
    {
        if (!root) return 0;
        int lf = 0, ri = 0;
        if (root -> left)
            lf = heightTree(root -> left);
        if (root -> right)
            ri = heightTree(root -> right);
        return max(lf, ri) + 1;
    }
    
    bool isBalanced(TreeNode *root) {
        if (!root) return true;
        bool lf, ri;
        lf = isBalanced(root -> left);
        ri = isBalanced(root -> right);
        return lf && ri && (abs(heightTree(root->left)-heightTree(root->right))<=1);
    }
};

/**
 * 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 heightTree(TreeNode *root)
    {
        if (!root) return 0;
        int lf = 0, ri = 0;
        if (root -> left)
            lf = heightTree(root -> left);
        if (root -> right)
            ri = heightTree(root -> right);
        return max(lf, ri) + 1;
    }
    
    bool isBalanced(TreeNode *root) {
        if (!root) return true;
        
        stack<TreeNode *> sta;
        TreeNode *p = root;
        
        while(p || !sta.empty())
        {
            while(p)
            {
                sta.push(p);
                p = p -> left;
            }
            if (!sta.empty())
            {
                p = sta.top();
                sta.pop();
                if (abs(heightTree(p -> left) - heightTree(p -> right)) > 1)
                    return false;
                p = p -> right;
            }
        }
        return true;
    }
};