判断二叉树是否平衡、是否完全二叉树、是否二叉排序树

最新推荐文章于 2023-07-12 13:56:14 发布

转载最新推荐文章于 2023-07-12 13:56:14 发布 · 1k 阅读

标签

#算法 #二叉树 #数据结构

算法同时被 2 个专栏收录

96 篇文章

订阅专栏

数据结构

4 篇文章

订阅专栏

http://blog.csdn.net/zhaojinjia/article/details/11891523

来自剑指offer

求树的深度

用递归做很简单，只要知道递归出口语句的别写错。

[cpp]view plaincopyprint? 
   
 struct BinaryTreeNode  
 {  
     int m_Value;  
     BinaryTreeNode* m_pLeft;  
     BinaryTreeNode* m_pRight;  
 };  
   
 int TreeDepth(BinaryTreeNode* pRoot)  
 {  
     if (pRoot == NULL)  
         return 0;  
   
     int nLeftDepth = TreeDepth(pRoot->m_pLeft);  
     int nRightDepth = TreeDepth(pRoot->m_pRight);  
   
     return (nLeftDepth>nRightDepth)?(nLeftDepth+1):(nRightDepth+1);  
 }  

判断该树是否为平衡二叉树

方法一：调用上述函数求每个节点的左右孩子深度

[cpp]view plaincopyprint? 
   
 bool IsBalanced(BinaryTreeNode* pRoot)  
 {  
     if(pRoot== NULL)  
         return true;  
   
     int nLeftDepth = TreeDepth(pRoot->m_pLeft);  
     int nRightDepth = TreeDepth(pRoot->m_pRight);  
     int diff = nRightDepth-nLeftDepth;  
   
     if (diff>1 || diff<-1)  
         return false;  
   
     return IsBalanced(pRoot->m_pLeft)&&IsBalanced(pRoot->m_pRight);  
 }  

方法二：由于上述方法在求该结点的的左右子树深度时遍历一遍树，再次判断子树的平衡性时又遍历一遍树结构，造成遍历多次。因此方法二是一边遍历树一边判断每个结点是否具有平衡性。

[cpp]view plaincopyprint? 
   
 bool IsBalanced(BinaryTreeNode* pRoot, int* depth)  
 {  
     if(pRoot== NULL)  
     {  
         *depth = 0;  
         return true;  
     }  
   
     int nLeftDepth,nRightDepth;  
     bool bLeft= IsBalanced(pRoot->m_pLeft, &nLeftDepth);  
     bool bRight = IsBalanced(pRoot->m_pRight, &nRightDepth);  
       
     if (bLeft && bRight)  
     {  
         int diff = nRightDepth-nLeftDepth;  
         if (diff<=1 && diff>=-1)  
         {  
             *depth = 1+(nLeftDepth > nRightDepth ? nLeftDepth : nRightDepth);  
             return true;  
         }  
     }  
       
     return false;  
 }  
   
 bool IsBalanced(BinaryTreeNode* pRoot)  
 {  
     int depth = 0;  
   
     return IsBalanced(pRoot, &depth);  
 }  

http://www.cnblogs.com/luxiaoxun/archive/2012/08/04/2622786.html

判断二叉树是否平衡、是否完全二叉树、是否二叉排序树

1.判断二叉树是否平衡

//求树的高度
int TreeDepth(Node* t)
{
    int hl,hr,h;
    if(t != NULL)
    {
        hl = TreeDepth(t->left);
        hr = TreeDepth(t->right);
        h = hl>hr? hl:hr;
        return h+1;
    }
    return 0;
}

//判断二叉树是否平衡
int isBalanced(Node* t)  
{ 
    if(t==NULL) return 1; 
    int leftDepth = TreeDepth(t->left); 
    int rightDepth = TreeDepth(t->right); 
    if(abs(leftDepth-rightDepth) > 1) 
        return 0; 
    else 
        return isBalanced(t->left) && isBalanced(t->right); 
}

2.判断二叉树是否相同

//判断两棵二叉树是否相同
int CompTree(Node* tree1, Node* tree2)
{
    if(tree1 == NULL && tree2 == NULL)
        return 1;
    else if(tree1 == NULL || tree2 == NULL)
        return 0;
    if(tree1->data != tree2->data)
        return 0;
    if(CompTree(tree1->left,tree2->left)==1 && CompTree(tree1->right,tree2->right)==1)
        return 1;
    //反转二叉树也可能相同
    if(CompTree(tree1->left,tree2->right)==1 && CompTree(tree1->right,tree2->left)==1)
        return 1;
    return 0;
}

//拷贝二叉树   
void CopyTree(Node* s,Node* & d)  
{  
    if(s==NULL) d = NULL;  return ;
    Node* temp = new Node;  
    temp->data = s->data;  
    if(d==NULL) d = temp;  
    if(s->left) CopyTree(s->left,d->left);  
    if(s->right) CopyTree(s->right,d->right);  
}

3.判断二叉树是否完全二叉树

判断二叉树是否是完全二叉树：层次遍历二叉树，遍历的左右节点入队列。若出队列的结点为空，则以后出队列的结点都为空，则为完全二叉树，否则不是

int ComplateTree(Node* bt)
{
    Node* p=bt;
    queue<Node*> q;
    int tag=0;
    if(p==NULL) return 1;
    q.push(p);
    while(!q.empty())
    {
         p=q.front(); q.pop(); 
         if(p->left && !tag) q.push(p->left);
         else if(p->left)  return 0;
         else tag=1;
         if(p->right && !tag) q.push(p->right);
         else if(p->right)  return 0;
         else tag=1;
    }
    return 1;
}

4.判断二叉树是否二叉排序树

判断二叉树是否是二叉排序树（BST）：根据中序遍历序列是否升序来判断

bool IsBinarySortTree(Node* bt)
{
    stack<Node*> s;
    Node* p = bt;
    Node* pre = NULL;   // pre保持为p的中序前驱
    while(p || !s.empty())
    {
        if(p)
        {
            s.push(p);
            p = p->left;
        }
        else
        {
            p = s.top(); s.pop();
            if( pre && (p->data <= pre->data) )  return false;  // 不是二叉排序树
            pre = p;   // 记下前驱结点
            p = p->right;
        }
    }
    return true;  // 二叉排序树
}

判断二叉树是否是二叉排序树（BST）：层次遍历二叉树，若出队列的结点小于左结点的值，或者是大于右结点的值，则不是BST，否则是BST（感觉不对，BST要求左子树所有节点小于根节点，右子数所有节点大于跟节点，层次遍历出队只只比较左右节点而不是所有节点，应该不对！！！）

bool IsBST(Node* T)
{
    queue<Node*> q;
    Node* p;
    if(T == NULL) return true;
    q.push(T);
    while(!q.empty())
    {
        p = q.front(); q.pop();
        if(p->left)
          if(p->data < p->left->data)
             return false;
          else q.push(p->left);
        if(p->right)
          if(p->data > p->right->data)
             return false;
          else q.push(p->right);
    }
    return true;
}