【剑指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 < - || diff > )
     {
         return false;
     }

---

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

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

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

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

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

     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<<"\t";
 }

 //前序遍历二叉树
 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 ;
     }

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

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

 //判断是否平衡二叉树，求每个结点的深度，有重复遍历
 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 < - || diff > )
     {
         return false;
     }

     return true;
 }

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

     size_t lchildDepth = ;
     size_t rchildDepth = ;

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

     int diff = lchildDepth - rchildDepth;

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

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

 bool IsBanlancedTree(const PBTNode &pRoot)
 {
     size_t Depth = ;
     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 ()
     {
         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 ;
 }

测试结果：

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 :
IsBanlancedTreeBasic :
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 :
IsBanlancedTreeBasic :
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 :
IsBanlancedTreeBasic :
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 :
IsBanlancedTreeBasic :
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 :
IsBanlancedTreeBasic :
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 :
IsBanlancedTreeBasic :
Test DestoryBiTree...
Please enter the binary tree,'*' for leaf node
**
The pre order is :
        请按任意键继续. . .