二叉树的基础（遍历、深度、二叉树相等、判断平衡二叉树）

1、求解二叉树的深度 
一般的方法是使用后序遍历递归来实现。

typedef struct Node
{
    char data;
    struct Node *Lchild;
    struct Node *Rchild;
    struct Node *parent;
}BNode,*BTree;


int PostTreeDepth(BTree root){
    int LHeight,RHeight,max;
    if(root != NULL)
    {
        LHeight = PostTreeDepth(root->Lchild);
        RHeight = PostTreeDepth(root->Rchild);
        max = LHeight>RHeight?LHeight:rightchild;
    }
    return (max+1);
}

//
总结：非递归算法求解深度后序需要了解。

2、判断两棵二叉树是否相等

typedef struct _TreeNode{
    char c;
    TreeNode *letfchild;
    TreeNode *rightchild;
}TreeNode;


//判断两棵二叉树是否相等，
//(1)左子树==左子树 右子树==右子树
//(2)左子树==右子树 右子树==左子树
int compareTree(TreeNode *tree1,TreeNode *tree2){
    if(!tree1 && !tree2) return true;
    if((tree1 && !tree2)||(!tree1 && tree2)) return flase;
    if(tree1 && tree2){
        if(tree1->c == tree2->c){
                //(1)
         if(compareTree(tree1->letfchild,tree2->rightchild))
                return compareTree(tree1->rightchild,tree2->rightchild);
         //(2)
         else if(compareTree(tree1->letfchild == tree2->rightchild))
            return compareTree(tree1->rightchild,tree2->letfchild);
        }        
    }
}

3、判断二叉树是否是平衡树
输入一棵二叉树的根结点，判断该树是不是平衡二叉树。如果某二叉树中任意结点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
涉及到的知识点：二叉树的深度的求解


方法1、（先序遍历算法）
在遍历树的每个结点的时候，调用函数TreeDepth得到它的左右子树的深度。如果每个结点的左右子树的深度相差都不超过1，按照定义它就是一棵平衡的二叉树。

bool IsBalanced(BinaryTreeNode* pRoot)
{
    if(pRoot == NULL)
        return true;
    int left = TreeDepth(pRoot->m_pLeft); //求深度的算法
    int right = TreeDepth(pRoot->m_pRight);


    int diff = left - right;


    if(diff > 1 || diff < -1)
        return false;
    return IsBalanced(pRoot->m_pLeft) && IsBalanced(pRoot->m_pRight);
}

思路：
代码简洁，但是，每一个节点都会被重复遍历多次，时间效率不高。


方法2、后序遍历算法
在遍历二叉树的每一个节点，之前就已经遍历了它的左右子树，只要遍历每一个节点的时候记录它的深度（某一个节点的深度等于它的叶子节点的路径的长度），这样我们可以一边遍历一边判断每一个节点是不是平衡。

bool IsBalanced(BinaryTreeNode* pRoot, int* pDepth)
{
    if(pRoot == NULL)
    {
        *pDepth = 0;
        return true;
    }


    int left, right;
    if(IsBalanced(pRoot->m_pLeft,&left) && IsBalanced(pRoot->m_pRight,&right))
    {
        int diff = left - right;
        if(diff <= 1 && diff >= -1)
        {
            //孩子的深度+1
            *pDepth = 1 + (left > right ? left : right);
            return true;
        }
    }
    return false;
}

我们只需要给上面的函数传入二叉树的根结点以及一个表示结点深度的整形变量就可以了：

bool IsBalanced(BinaryTreeNode* pRoot)
{
    int depth = 0;
    return IsBalanced(pRoot, &depth);
}

c++ 的写法：
//判断二叉树是平衡树
/*
每个节点的左右子树的高度相差小于等于1
1）二叉树的高度
2）判断左右子树的高度差即可
*/

int TreeHeight(const Node* root,bool &balanced){
    //节点的做孩子UC妮子啊，就就出做孩子的高度
    const int LHeight = root->left?TreeHeight(root->left,balanced)+1:0;
    if(!balanced) return 0;
    const int RHeight = root->right?TreeHeight(root->right,balanced)+1:0;
    if(!balanced) return 0;
    
    const int diff = LHeight - RHeight;
    
    if(diff <-1 || diff>1) balanced = false;
    return(LHeight>RHeight?LHeight:RHeight);
}
bool IsBalancedTree(const Node* root)
{
    bool balanced = tree;
    if(root)
        TreeHeight(root,balanced);
    
    return balanced;
}

总结：
后面的方法是一种后序遍历的算法，这样就可以之久总叶子节点开始判断是否为平衡二叉树了。