【剑指offer】面试题39-二叉树的深度

题目一：

问题描述：

输入一棵二叉树的根节点，求出二叉树的深度。二叉树的深度就是二叉树中从根节点到叶子结点形成的最长路径的长度。

---

问题分析：

求出左子树的深度和右子树的深度，树的深度就是左右子树深度较大值加1.

---

代码实现：

#include<iostream>
using namespace std;
#include<cassert>
struct BinaryNode
{
    int _data;
    BinaryNode* _left;
    BinaryNode* _right;
    BinaryNode(int x = 0)
       :_data(x)
       ,_left(NULL)
       ,_right(NULL)
    {}
};
class BinaryTreeOfDepth
{
    typedef BinaryNode Node;
public:
    BinaryTreeOfDepth(int arr[],int len,const int& invalid)
    {
       size_t index = 0;
       _root = _Create(arr,len,index,invalid);
    }
    size_t GetDepth()
    {
       return _GetDepth(_root);
    }
protected:
    Node* _Create(int arr[], int len, size_t& index, const int& invalid)
    {
       assert(arr);
       Node* root = NULL;
       if(index < len && invalid != arr[index])
       {
           root = new Node(arr[index]);
           root->_left = _Create(arr,len,++index,invalid);
           root->_right = _Create(arr,len,++index,invalid);
       }
       return root;
    }
    size_t _GetDepth(Node* root)
    {
       if(root == NULL)
           return 0;
       int left = _GetDepth(root->_left);//求左子树的高度
       int right = _GetDepth(root->_right);//求右子树的高度
       return left > right ? (left + 1):(right + 1);
    }
protected:
    Node* _root;
};
int main()
{
    //int arr[] = {2,3,6,12,'#','#','#',7,8,10};
    //int arr[] = {1};
    int arr[] = {1,2,3,4,5};
    BinaryTreeOfDepth bt(arr,sizeof(arr)/sizeof(arr[0]),'#');
    cout<<bt.GetDepth()<<endl;
    system("pause");
    return 0;
}

---

题目二：

问题描述：

输入一棵二叉树的根节点，判断是否是平衡二叉树。如果某二叉树中任意结点的左右子树的深度差不差超过1，那么它就是平衡二叉树。

---

问题分析：

方法1：先去求出二叉树的左右深度，然后再去判断是否是平衡二叉树。这样一来，求深度需要遍历一次二叉树，判断平衡也需要遍历，效率也不是很高。
方法2：如果判断是否是平衡树的时候，顺带也可以去求出深度的话，然后将深度带回给上一层，这样一课二叉树只需要遍历一次。
如何带回深度？
1、可以加一个参数，是深度的引用，这样每次得到的深度直接赋值给参数即可。
2、加一个参数，是深度的地址，求得深度直接修改地址对应的值。
（1，2，类似）
3、返回深度，既要返回是否是平衡树，又要返回深度，所以我们就可以返回pair

代码实现：

代码实现：
#include<iostream>
using namespace std;
#include<cassert>
struct BinaryNode
{
    int _data;
    BinaryNode* _left;
    BinaryNode* _right;
    BinaryNode(int x = 0)
       :_data(x)
       ,_left(NULL)
       ,_right(NULL)
    {}
};
//判断是否是平衡二叉树
class Soluation
{
    typedef BinaryNode Node;
public:
    Soluation(int arr[],int len,const int& invalid)
    {
       size_t index = 0;
       _root = _Create(arr,len,index,invalid);
    }
    bool IsBalance()
    {
       int depth = 0;
       return _IsBalance(_root,depth);
    }
protected:
    Node* _Create(int arr[], int len, size_t& index, const int& invalid)
    {
       assert(arr);
       Node* root = NULL;
       if(index < len && invalid != arr[index])
       {
           root = new Node(arr[index]);
           root->_left = _Create(arr,len,++index,invalid);
           root->_right = _Create(arr,len,++index,invalid);
       }
       return root;
    }
    //每次判断是否是AVL的时候，传一个整形数，防止多遍历一次二叉树
    bool _IsBalance(Node* root, int& depth)
    {
       if(root == NULL)
       {
           depth = 0;
           return true;
       }
       int left = 0;
       int right = 0;
       if(_IsBalance(root->_left,left) && _IsBalance(root->_right,right))
       {
           int diff = left - right;
           if(diff >= -1 && diff <= 1)
           {
               depth = (left > right ) ? (left + 1):(right + 1);
               return true;
           }
       }
       return false;
    }
protected:
    Node* _root;
};
int main()
{
    //int arr[] = {2,3,6,12,'#','#','#',7,8};
    //int arr[] = {1};
    int arr[] = {1,2,3,4,5};
    //int arr[] = { 1, 2, 3, '#', '#', 4, '#' , '#', 5, 6 };
    Soluation bt(arr,sizeof(arr)/sizeof(arr[0]),'#');
    cout<<bt.IsBalance()<<endl;
    system("pause");
    return 0;
}