对于平衡二叉树中的每个节点，左子子树和右子子树的高度最大差值为1。

二叉树的高度是指从根节点到最远离根节点的子节点的距离。

下面是一个示例：

           2 <-- root: Height 1
          / \
         7   5 <-- Height 2
        / \   \
       2   6   9 <-- Height 3
          / \  /
         5  11 4 <-- Height 4 

二叉树的高度：4

以下是二进制树和有关它们是否平衡的报告：

上面的树是不平衡的。

上面的树是平衡的。

编写尽可能短的程序，该程序接受二叉树的根作为输入，如果树不平衡，则返回假值，如果树平衡，则返回真值。

输入值

二叉树的根。这可能是以对根对象的引用或什至是二叉树的有效表示形式的列表的形式。

输出量

返回真实值：如果树是平衡的

返回falsey值：如果树为un平衡。

二叉树的定义

树是一个对象，其中包含一个值以及另外两个树或指向它们的指针。

二叉树的结构如下所示：

typedef struct T
{
   struct T *l;
   struct T *r;
   int v;
}T;

如果将列表表示形式用于二叉树，则其外观可能类似于以下内容：

[root_value, left_node, right_node]

果冻，11字节

ḊµŒḊ€IỊ;߀Ạ

在线尝试！

空树由表示[]。

Prolog（SWI），49字节

N+_/B/C:-X+B,Y+C,abs(X-Y)<2,N is max(X,Y)+1.
0+e.

在线尝试！

将树表示为Value/Left_Child/Right_Child，空树为原子e。Defines +/2通过成功或失败输出，左边有一个未绑定的变量（或一个已经等于树的高度的变量），左边是一棵树-如果height参数不可接受，则添加9个字节来定义-T:-_+T.。

N + _/B/C :-            % If the second argument is a tree of the form _Value/B/C,
    X+B,                % X is the height of its left child which is balanced,
    Y+C,                % Y is the height of its right child which is balanced,
    abs(X-Y) < 2,       % the absolute difference between X and Y is strictly less than 2,
    N is max(X,Y)+1.    % and N is the height of the full tree.
0 + e.                  % If, on the other hand, the second argument is e, the first is 0.

Wolfram语言（Mathematica），50个字节

f@_[x_,y_]:=f@x&&f@y&&-2<Depth@x-Depth@y<2;f@_=1>0

使用Null对空，value[left, right]对节点。例如，下面的树写为2[7[2[Null, Null], 6[5[Null, Null], 11[Null, Null]]], 5[Null, 9[4[Null, Null], Null]]]。

    2
   / \
  7   5
 / \   \
2   6   9
   / \  /
  5  11 4

在线尝试！

Python 3.8（预发行版），133125字节

b=lambda t:((max(l[0],r[0])+1,abs(l[0]-r[0])<2)if(l:=b(t[1]))[1]and(r:=b(t[2]))[1]else(0,0))if t else(0,1)
h=lambda t:b(t)[1]

在线尝试！

采取“列表”格式的树：节点[value, left, right]与节点left并right为节点。

调用功能h。

退货0或False表示不平衡的树。返回1或True表示平衡树。

取消高尔夫：

# Returns tuple (current height, subtrees are balanced (or not))
def balanced(tree):
  if tree: # [] evaluates to False
    left = balanced(tree[1])
    right = balanced(tree[2])
    # If  the subtrees are not both balanced, nothing to do, just pass it up
    if left[1] and right[1]:
      height = max(left[0], right[0]) + 1
      subtrees_balanced = abs(left[0] - right[0]) < 2
    else:
      height = 0 # Value doesn't matter, will be ignored
      subtrees_balanced = False
  else:
    height = 0
    subtrees_balanced = True
  return (height, subtrees_balanced)

def h(tree):
  return balanced(tree)[1]

-10：逆逻辑摆脱nots

如果允许在调用过程中接受参数，则可以将其缩短为（115字节）

(b:=lambda t:((max(l[0],r[0])+1,abs(l[0]-r[0])<2)if(l:=b(t[1]))[1]and(r:=b(t[2]))[1]else(0,0))if t else(0,1))(_)[1]

与_被树检查。

JavaScript（Node.js），49字节

h=([l,r])=>l?(d=h(l)-h(r))*d<2?1+h(d>0?l:r):NaN:1

在线尝试！

-9个字节，由Arnauld提供。

JavaScript，58个字节

h=([l,r])=>l?(l=h(l),r=h(r),m=l>r?l:r,m+m-l-r<2?m+1:NaN):1

在线尝试！

使用[]对空，[left, right, value]对节点。

JavaScript，162个字节

f=x=>{for(f=0,s=[[x,1]];s[0];){if(!((d=(t=s.pop())[0]).a&&d.b||f))f=t[1];if(f&&t[1]-f>1)return 0;if(d.a)s.push([d.a,t[1]+1]);if(d.b)s.push([d.b,t[1]+1])}return 1}

在线尝试！

输入的格式是一个对象

root={a:{node},b:{node},c:value}

说明

for(f=0,s=[[x,1]];s[0];){if(!((d=(t=s.pop())[0]).a&&d.b||f))f=t[1]

执行广度优先搜索可以找到缺少一个或多个分支的第一个节点的深度。

if(f&&t[1]-f>1)return 0;if(d.a)s.push([d.a,t[1]+1]);if(d.b)s.push([d.b,t[1]+1])}

继续进行广度优先搜索，如果任何元素比缺少分支的第一个节点的深度深两个，则返回零。

return 1}

如果找不到这样的节点，则返回1

朱莉娅56字节

f(t)=t!=()&&(-(f.(t.c)...)^2<2 ? maximum(f,t.c)+1 : NaN)

使用以下表示二进制树的结构：

struct Tree
    c::NTuple{2,Union{Tree,Tuple{}}}
    v::Int
end

c是表示左节点和右节点的元组，空元组()用于表示不存在节点。

Falsey的值为NaN，任何整数都是true的。

科特林，67个字节

fun N.c():Int=maxOf(l?.c()?:0,r?.c()?:0)+1
fun N.b()=l?.c()==r?.c()

哪里

data class N(val l: N? = null, val r: N? = null, val v: Int = 0)

在线尝试！

C，117字节

h(T*r){r=r?1+h(h(r->l)>h(r->r)?r->l:r->r):0;}b(T*r){return r->l&&!b(r->l)||r->r&&!b(r->r)?0:abs(h(r->l)-h(r->r))<=1;}

结构实现如下：

 typedef struct T
    {
        struct T * l;

        struct T * r;

        int v;

    } T;

在JDoodle上尝试

Python 2中，99个 96 94字节

lambda A:A==[]or(abs(D(A[1])-D(A[2]))<2)*f(A[1])*f(A[2])
D=lambda A:A>[]and-~max(map(D,A[1:]))

在线尝试！

离Jo King 3个字节。

将输入作为：空节点为[]，其他节点为[<value>, <leftNode>, <rightNode>]。输出0/1为False / True。