【剑指offer】判断二叉树是否为平衡二叉树

2013-09-03 14:16:51

面试题39：求二叉树的深度、判断二叉树是否为平衡二叉树

小结：

1. 根据平衡二叉树的定义，需要判断每个结点，因此，需要遍历二叉树的所有结点，并判断以当前结点为根的树是否为二叉树；
2. 用后序遍历的方式，先判断左右子树是否为平衡的，在判断当前节点；
3. 可以对每个结点求深度，根据深度判断，如函数IsBanlancedTreeBasic所示，但这种方法存在重复遍历，效率较低；
4. 后序遍历时，一边判断是否为平衡二叉树，一边求而二叉树的深度，这样就避免了重复遍历，如函数IsBanlancedTree所示。

代码编写注意事项：

1. 注意IsBanlancedTreeSub中需同时带回深度，因此在返回为true时，需要更新*pDepth的值；
2. 写代码时，注意下面的代码由于优先级会造成错误

if ( (lchilDepth - rchilDepth) < -1 || (lchilDepth - rchilDepth) > 1)

因此改为：

int diff = lchilDepth - rchilDepth;
    if ( diff < -1 || diff > 1)
    {
        return false;
    }

---

代码（测试通过，暂未发现问题，欢迎交流指正）：

#include <iostream>
#include <cassert>
using namespace std;

typedef char DataType;
const DataType LeafNode = '*';
const size_t SIZE = 1000;

typedef struct binaryTreeNode
{
    DataType data;
    binaryTreeNode *lchild;
    binaryTreeNode *rchild;
}BTNode,*PBTNode;

//创建二叉树
PBTNode CreatBiTree(PBTNode &pRoot)
{
    DataType newData = 0;

    cin>>newData;

    if (newData == LeafNode)
    {
        return NULL;
    }

    pRoot = new BTNode;
    pRoot->data = newData;

    pRoot->lchild = CreatBiTree(pRoot->lchild);
    pRoot->rchild = CreatBiTree(pRoot->rchild);

    return pRoot;
}

//访问二叉树结点
void VisitBiTreeNode(const PBTNode &pBTNode)
{
    assert(NULL != pBTNode);
    cout<<pBTNode->data<<"	";
}

//前序遍历二叉树
void PreOrder(const PBTNode &pRoot)
{
    if (pRoot != NULL)
    {
        VisitBiTreeNode(pRoot);
        PreOrder(pRoot->lchild);
        PreOrder(pRoot->rchild);
    }
}

//中序遍历二叉树
void InOrder(const PBTNode &pRoot)
{
    if (pRoot != NULL)
    {
        InOrder(pRoot->lchild);
        VisitBiTreeNode(pRoot);
        InOrder(pRoot->rchild);
    }
}

//后序遍历二叉树
void PostOrder(const PBTNode &pRoot)
{
    if (pRoot != NULL)
    {
        PostOrder(pRoot->lchild);
        PostOrder(pRoot->rchild);
        VisitBiTreeNode(pRoot);
    }
}

//求二叉树深度
size_t GetDepthOfBiTree(const PBTNode &pRoot)
{
    if (NULL == pRoot)
    {
        return 0;
    }

    size_t lchilDepth = GetDepthOfBiTree(pRoot->lchild);
    size_t rchilDepth = GetDepthOfBiTree(pRoot->rchild);

    return ( (lchilDepth > rchilDepth) ? (lchilDepth + 1) : (rchilDepth + 1) );
}


//判断是否平衡二叉树，求每个结点的深度，有重复遍历
bool IsBanlancedTreeBasic(const PBTNode &pRoot)
{
    if (pRoot == NULL)   //若左子树为空，右子树的深度超过1，判断会出错
        return true;

    //return ( IsBanlancedTree(pRoot->lchild) && IsBanlancedTree(pRoot->rchild) );

    if ( !IsBanlancedTreeBasic(pRoot->lchild) || !IsBanlancedTreeBasic(pRoot->rchild) )
    {
        return false;
    }

    size_t lchilDepth = GetDepthOfBiTree(pRoot->lchild);
    size_t rchilDepth = GetDepthOfBiTree(pRoot->rchild);
    int diff = lchilDepth - rchilDepth;
    //if ( (lchilDepth - rchilDepth) < -1 || (lchilDepth - rchilDepth) > 1)
    if ( diff < -1 || diff > 1)
    {
        return false;
    }

    return true;
}

//判断是否平衡二叉树，优化，没有重复遍历
bool IsBanlancedTreeSub(const PBTNode &pRoot,size_t *pDepth)
{
    if (pRoot == NULL)  
    {
        *pDepth = 0;
        return true;
    }

    size_t lchildDepth = 0;
    size_t rchildDepth = 0;

    if ( !IsBanlancedTreeSub(pRoot->lchild,&lchildDepth) || !IsBanlancedTreeSub(pRoot->rchild,&rchildDepth) )
    {
        return false;
    }

    int diff = lchildDepth - rchildDepth;

    if ( diff < -1 || diff > 1)
    {
        return false;
    }

    *pDepth = lchildDepth > rchildDepth ? (lchildDepth + 1) : (rchildDepth + 1);
    return true;
}

bool IsBanlancedTree(const PBTNode &pRoot)
{
    size_t Depth = 0;
    return IsBanlancedTreeSub(pRoot,&Depth);
}


void DestoryBiTreeNode(PBTNode pRoot)
{
    delete pRoot;
}

//销毁二叉树
void DestoryBiTree(PBTNode &pRoot)
{
    if (pRoot != NULL)
    {
        DestoryBiTree(pRoot->lchild);
        DestoryBiTree(pRoot->rchild);
        DestoryBiTreeNode(pRoot);
    }
}

//测试二叉树相关操作
void TestBinaryTree()
{
    PBTNode pRoot = NULL;

    cout<<"Test IsBanlancedTree..."<<endl;

    //测试IsBanlancedTree
    while (1)
    {
        cout<<"Please enter the binary tree,'*' for leaf node"<<endl;
        CreatBiTree(pRoot);

        //Test PreOrder...
        //cout<<"Test PreOrder..."<<endl;
        cout<<"The pre order is :"<<endl;
        PreOrder(pRoot);
        cout<<endl;

        //Test InOrder...
        //cout<<"Test InOrder..."<<endl;
        cout<<"The in order is :"<<endl;
        InOrder(pRoot);
        cout<<endl;

        //Test PostOrder...
        //cout<<"Test PostOrder..."<<endl;
        cout<<"The post order is :"<<endl;
        PostOrder(pRoot);
        cout<<endl;

        cout<<"IsBanlancedTree : "<<IsBanlancedTree(pRoot)<<endl;
        cout<<"IsBanlancedTreeBasic : "<<IsBanlancedTreeBasic(pRoot)<<endl;

        cout<<"Test DestoryBiTree..."<<endl;
        DestoryBiTree(pRoot);
    }

    /*cout<<"Test DestoryBiTree..."<<endl;
    DestoryBiTree(pRoot);*/
}

int main()
{
    TestBinaryTree();
    return 0;
}

测试结果：

Test IsBanlancedTree...
Please enter the binary tree,'*' for leaf node
ab**c**
The pre order is :
a       b       c
The in order is :
b       a       c
The post order is :
b       c       a
IsBanlancedTree : 1
IsBanlancedTreeBasic : 1
Test DestoryBiTree...
Please enter the binary tree,'*' for leaf node
ab***
The pre order is :
a       b
The in order is :
b       a
The post order is :
b       a
IsBanlancedTree : 1
IsBanlancedTreeBasic : 1
Test DestoryBiTree...
Please enter the binary tree,'*' for leaf node
a**
The pre order is :
a
The in order is :
a
The post order is :
a
IsBanlancedTree : 1
IsBanlancedTreeBasic : 1
Test DestoryBiTree...
Please enter the binary tree,'*' for leaf node
abc****
The pre order is :
a       b       c
The in order is :
c       b       a
The post order is :
c       b       a
IsBanlancedTree : 0
IsBanlancedTreeBasic : 0
Test DestoryBiTree...
Please enter the binary tree,'*' for leaf node
abcd****e*f**
The pre order is :
a       b       c       d       e       f
The in order is :
d       c       b       a       e       f
The post order is :
d       c       b       f       e       a
IsBanlancedTree : 0
IsBanlancedTreeBasic : 0
Test DestoryBiTree...
Please enter the binary tree,'*' for leaf node
abd**e**cf***
The pre order is :
a       b       d       e       c       f
The in order is :
d       b       e       a       f       c
The post order is :
d       e       b       f       c       a
IsBanlancedTree : 1
IsBanlancedTreeBasic : 1
Test DestoryBiTree...
Please enter the binary tree,'*' for leaf node
**
The pre order is :
        请按任意键继续. . .