判断是不是平衡二叉树

int max(int a,int b)
{
    return a>b?a:b;
}

int depth(struct TreeNode* pRoot,int cnt)
{
    if(!pRoot)
        return cnt;
    cnt++;
    return max(depth(pRoot->left,cnt),depth(pRoot->right,cnt));
}

bool IsBalanced_Solution(struct TreeNode* pRoot ) {
    if(!pRoot)
        return true;
    int delta=depth(pRoot->left,0)-depth(pRoot->right, 0);
    if(delta<-1||delta>1)
        return false;
    if(IsBalanced_Solution(pRoot->left)&&IsBalanced_Solution(pRoot->right))
        return true;
    return false;
    
}

int TreeHeight(struct TreeNode *pRoot) {
    int LeftHeight, RightHeight;
    if(pRoot==NULL)
        return 0;
    LeftHeight = TreeHeight(pRoot->left);
    RightHeight = TreeHeight(pRoot->right);
    return (LeftHeight>RightHeight ? LeftHeight: RightHeight)+1;
}
bool IsBalanced_Solution(struct TreeNode* pRoot ) {
    int HeightSUB;
    if(pRoot==NULL)
        return true;
    HeightSUB = TreeHeight(pRoot->left)-TreeHeight(pRoot->right);
    if(HeightSUB>1 || HeightSUB<-1)
        return false;
    if(IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right))
        return true;
    return false;
}

平衡二叉树是一种二叉树，它具有以下特点：

1. 对于任意一个节点，它的左子树和右子树的高度差不超过1。
2. 左子树和右子树也都是平衡二叉树。

   //求平衡二叉树的高度
   int maxDepth(struct TreeNode*root)
   {
       //根节点为空
       if(!root)
       {
           //高度为0
           return 0;
       }
       //遍历左右子树
       int lDepth=maxDepth(root->left);
       int rDepth=maxDepth(root->right);
       //返回较高的一边，算上根节点+1
       return lDepth>rDepth?(lDepth+1):(rDepth+1);
   }
   //判断是否为平衡二叉树
   bool IsBalanced_Solution(struct TreeNode* pRoot ) 
   {
       // write code here
       //根节点为空
       if(!pRoot)
       {
           return true;
       }
       //遍历左右子树高度
       int lDepth=maxDepth(pRoot->left);
       int rDepth=maxDepth(pRoot->right);
       //左右子树高度差
       int l_r_hight=abs(lDepth-rDepth);
       //左右子树高度差小于等于1，同时存在左右节点
       if(l_r_hight<=1&&IsBalanced_Solution(pRoot->left)&&IsBalanced_Solution(pRoot->right))
       {
           return true;
       }
       //不是平衡二叉树
       return false;
   }

   
   

int bfs(struct TreeNode* root){
    if(root==NULL){
        return 0;
    }
    int left = bfs(root->left);
    int right = bfs(root->right);
    if(left==-1||right==-1){
        return -1;
    }
    if(((left - right)*(left-right))>1){
        return -1;
    }
    return (1+(left>right?left:right));
}

#include <stdbool.h>
bool IsBalanced_Solution(struct TreeNode* pRoot ) {
    int rtn = bfs(pRoot);
    return rtn!=-1;
}

int height_tree(struct TreeNode* pRoot)
{
    if(NULL==pRoot)return 0;
    int lh=height_tree(pRoot->left);
    int rh=height_tree(pRoot->right);
    return lh>rh?lh+1:rh+1;
}
bool IsBalanced_Solution(struct TreeNode* pRoot ) {
     if (NULL==pRoot) return true;
     int leftHeight = height_tree(pRoot->left);
     int rightHeight = height_tree(pRoot->right);
    return abs(leftHeight - rightHeight) <= 1 &&
        IsBalanced_Solution(pRoot->left) &&
          IsBalanced_Solution(pRoot->right) ;
}

调试了半天没调出来，思路是对的，最后还是照抄大佬的答案吧

int count(struct TreeNode* pRoot) {
    if(pRoot != NULL) {
        int left = count(pRoot->left);
        int right = count(pRoot->right);
        return (left>right?left:right)+1;
    }
    return 0;
}
bool IsBalanced_Solution(struct TreeNode* pRoot ) {
    // write code here
    if (pRoot == NULL) return true;
    int left=0,right=0,goal=false;
    left=count(pRoot->left);
    right=count(pRoot->right);
    int ret = left - right;
    if (ret <= 1 && ret >= -1) goal=true;
    return goal&&IsBalanced_Solution(pRoot->left)&&IsBalanced_Solution(pRoot->right);
}

int GetDeep(struct TreeNode *root){
    if(root != NULL){
        int left = GetDeep(root->left);
        int right = GetDeep(root->right);
        return (left>right?left:right)+1;
    }
    return 0;
}

int IsBalanced_Solution(struct TreeNode* pRoot ) {
    if(pRoot == NULL) return 1;
    int left = GetDeep(pRoot->left);
    int right = GetDeep(pRoot->right);
    if(abs(left - right) > 1) return 0;
    else return IsBalanced_Solution(pRoot->left)&&IsBalanced_Solution(pRoot->right);
}

#include <stdbool.h>

int dfs(struct TreeNode* root, bool* ans) {
  if (!root) return 0;
  const int lh = dfs(root->left,  ans); // lh == left subtree height
  const int rh = dfs(root->right, ans); // rh == right subtree height
  if (abs(lh - rh) > 1) *ans = false;
  return 1 + fmax(lh, rh);
}

bool IsBalanced_Solution(struct TreeNode* pRoot ) {
  if (!pRoot) return true;
  bool ans = true;
  dfs(pRoot, &ans);
  return ans;
}