面试题39：获得二叉树深度和判断是否是平衡二叉树

1， 二叉树深度，一个简单的递归

2， 是否是平衡二叉树，一个略复杂的递归

见代码：

#include<iostream>

using namespace std;

struct TreeNode{
    TreeNode* pleft;
    TreeNode* pright;
    int value;

    TreeNode(int v){
        value =  v;
        pleft = NULL;
        pright = NULL;
    }
};

TreeNode* build_tree(){
    TreeNode* T1 = new TreeNode(1);
    TreeNode* T2 = new TreeNode(2);
    TreeNode* T3 = new TreeNode(3);
    TreeNode* T4 = new TreeNode(4);
    TreeNode* T5 = new TreeNode(5);
    TreeNode* T6 = new TreeNode(6);
    TreeNode* T7 = new TreeNode(7);
    TreeNode* T8 = new TreeNode(8);
    TreeNode* T9 = new TreeNode(9);
    TreeNode* T10 = new TreeNode(10);
    TreeNode* T11 = new TreeNode(11);
    T1->pleft = T2;
    T1->pright = T3;
    T2->pleft = T4;
    T2->pright = T5;
    T3->pleft = T6;
    T3->pright = T7;
    T6->pleft = T8;
    T6->pright = T9;
    T9->pleft = T10;
    T9->pright = T11;
    return T1;
}

int get_deeps(TreeNode* root){
    if(root == NULL){
        return 0;
    }
    int left_deeps = get_deeps(root->pleft);
    int right_deeps = get_deeps(root->pright);
    return left_deeps > right_deeps? (left_deeps+1):(right_deeps+1);
    
}

bool is_balance(TreeNode* root){
    if(root == NULL){
        return true;
    }
    int left_deeps = get_deeps(root->pleft);
    int right_deeps = get_deeps(root->pright);
    int diff = left_deeps - right_deeps;
    if(diff > 1 || diff < -1){
        return false;
    }
    return is_balance(root->pleft) && is_balance(root->pright);
}
int main(){
    //             1
    //           /   \
    //          2     3
    //         / \    / \
    //        4   5  6   7
    //               / \
    //              8   9
    //                 / \
    //                10 11
    TreeNode* root = build_tree();
    int deeps = get_deeps(root);
    cout << "deeps: "<< deeps << endl;
    bool is_balanced = is_balance(root);
    cout << "balance:" << is_balanced << endl;
    return 0;
}