判定一颗二叉树是否是平衡二叉树(AVL)

如题 自用笔记 如有错误欢迎及时指正

问题：给定一个二叉树，判定是否为平衡二叉树？

判定AVL：可以采用递归方式求出每个结点的左右子树高度，当任一结点左右子树高度差的绝对值小于等于1时，则满足avl的要求。

                空树 是avl

                非空树 左右子树均为avl

算法实现

bool IsAVL(BiTree T,int &h){            //h为树高度

    bool isLeft, isRight;       //保存左右子树的判定状态

    int hLeft, hRight;      //保存左右子树高度
    if(!T){
        h = 0;
        return true;        //空树是AVL
    }
    
    isLeft = IsAVL(T->lchild, hLeft);       //求左子树高 判断左子树满足avl
    isRight = IsAVL(T->rchild, hRight);     //求右子树高 判断右子树满足avl
    h = (hLeft > hRight ? hLeft : hRight) + 1;      //保存二叉树高度

    //核心部分

/*     if(isLeft==true&&isRight==true&&abs(hLeft-hRight)<=1){
        return true;
    }else{
        return false;
    } */
    //简洁写法
    return (isLeft == true && isRight == true && abs(hLeft - hRight) <= 1 ? true : false);
}

最优解法

bool isBalanced(BiTree root) {
    	//此时如果根节点的左右深度之差的返回值不为-1,即为正确的
        return Function(root)!=-1;
}
int Function(BiTree root){
        if(!root)return 0;

        //返回左(右)子树的深度,如果其深度为-1(默认不平衡),则全树不平衡
        int left=Function(root->lchild);
        if (left==-1)return -1;

        int right=Funtion(root->rchild);
        if (right==-1)return -1;
   
        return abs(left-right)<2?max(left,right)+1:-1;
}

存储结构与基本函数定义

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
typedef int DataType;
 
// 二叉树存储结构 二叉链式
typedef struct BiTNode{
    DataType data;  //数据域
    struct BiTNode *lchild;
    struct BiTNode *rchild;
} BiTNode, *BiTree; //重命名
 
typedef BiTree ElemType;
 
//操作函数 负责visit
inline void visit(BiTree p){
    printf("%d ", p->data);
}
 
//二叉树建立二叉链式
void CreateBiTree_BiTNode(BiTree &T){       
    DataType ch;     
    scanf("%d",&ch);
    //输入二叉树数据   
    if(ch==0) { //判断是否为空        
        T=NULL;
    }else {
        T=(BiTNode *)malloc(sizeof(BiTNode));  //二叉树的生成       
        T->data=ch;
            printf(" 二叉树新建节点并已插入数据%d",T->data);
            printf("\n");
        CreateBiTree_BiTNode(T->lchild);   
        CreateBiTree_BiTNode(T->rchild);     
    }    
}  

//层序遍历
void LevelTraverse(BiTree T){
    SqQueue Q;
    InitQueue(Q);
    BiTree p; //工作指针 保存出队元素负责访问
    
    EnQueue(Q, T);      //根节点入队
    while(!QueueEmpty(Q)){      
        DeQueue(Q, p);      //出队交给p       
        visit(p);    //访问
        if(p->lchild){      //左孩子不空入队
            EnQueue(Q, p->lchild);
        }
        if(p->rchild){                       
            EnQueue(Q, p->rchild);
        }
    }
}
 
//==============================================辅助队列
 
 
//存储结构循环队列
typedef struct{
    ElemType data[MaxSize];
    int front;          //队头
    int rear;           //队尾
} SqQueue;
//初始化
void InitQueue(SqQueue &q){
    q.front = q.rear = 0;
}
 
bool QueueEmpty(SqQueue q){
    if(q.front==q.rear){
        return true;
    }else{
        return false;
    }
}
 
//入队
bool EnQueue(SqQueue &q,ElemType x){
    if((q.rear+1)%MaxSize==q.front){        //队列已满
        return false;
    }
    q.data[q.rear] = x;
    q.rear = (q.rear + 1) % MaxSize;        //移动队列尾
    return true;
}
 
//出队
bool DeQueue(SqQueue &q,ElemType &x){
    if(q.front==q.rear){
        return false;
    }
    x = q.data[q.front];
    q.front = (q.front + 1) % MaxSize;
    return true;
}

//function

int main(){

    BiTree T1;
    CreateBiTree_BiTNode(T1);
    printf("二叉树T1为：\n");
    LevelTraverse(T1);

    int h=0;
    bool IS = IsAVL(T1,h);
    printf("\n");
    if(IS==true){
        printf("是AVL");
    }else{
        printf("不是AVL");
    }

    return 0;
}