leetcode【110】Balanced Binary Tree【c++，递归和非递归】

问题描述：

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

源码：

递归大法，记得求深度的题目。每次求深度的时候判断一下是否超标，这样也不用重复递归。超标直接返回-1。效率还可以。时间80%，空间100%。

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

再看看非递归的方法（栈）：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:  
    bool isBalanced(TreeNode* root) {
        if(!root)      return true;
        stack<TreeNode*> st;
        TreeNode *pre = NULL, *node=root;
        while(!st.empty() || node){
            if(node){
                // cout<<node->val<<endl;
                st.push(node);
                node = node->left;
            }
            else{
                node = st.top();
                // cout<<node->val<<endl;
                if(node->right==pre || !node->right){
                    // cout<<node->val<<endl;
                    st.pop();
                    pre = node;
                    if(!node->left || !node->right){
                        if(!node->left && !node->right)     node->val = 1;
                        else{
                            TreeNode* tmp = node->left? node->left: node->right;
                            if(tmp->val>=2)     return false;
                            node->val = tmp->val+1;
                        }
                    }
                    else{
                        int left = node->left->val;
                        int right = node->right->val;
                        if(abs(left-right)>1)   return false;
                        else    node->val = max(left, right)+1;
                    }
                    node = NULL;
                }
                else    node = node->right;
            }
        }
        return true;
    }
};