1.二叉搜索树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。（即中序遍历情况下，值依次增大）

 1 # 二叉搜索树
 2 # 中序遍历情况下，值递增则为二叉树
 3 def isBSTree(head):
 4     minimum = -100000               # 设定一个最小值
 5     if head is None:
 6         return False
 7     prenum = minimum
 8     stack = []
 9     while head or len(stack) > 0:
10         if head:
11             stack.append(head)
12             head = head.left
13         else:
14             head = stack.pop()
15             if head.val < prenum:   # 保证中序遍历情况下值递增
16                 return False
17             else:
18                 prenum = head.val
19             head = head.right
20     return True

2.完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。（除了最后一层之外的其他每一层都被完全填充，并且所有结点都保持向左对齐。）

 1 # 判断一棵树是否为完全二叉树
 2 # 左无、右有 ==> 返回 False
 3 # 左无、右无 ==> 激活判断：之后所有节点都是叶节点
 4 # 左有、右无 ==> 激活判断：之后所有节点都是叶节点        ==》      只要右无之后都必须是叶节点
 5 # 左有、右有 ==> 不用处理
 6 import queue
 7 def isCBTree(head):
 8     if not head:
 9         return False
10     que = queue.Queue()
11     que.put(head)
12     flag = False                                # 是否激活判断过程
13     while not que.empty():
14         head = que.get()
15         if head.left:
16             que.put(head.left)
17         if head.right:
18             que.put(head.right)
19 
20         if (not head.left) and head.right:      #左空、又不空必不为CBT
21             return False
22 
23         if flag:                                # 若过程激活则判断节点是否为叶节点
24             if head.left or head.right:
25                 return False
26 
27         if not (head.left and head.right):      # 左不空、右空 | 左空、右空
28             flag = True                         # 激活判断在此之后的节点必须为叶节点
29 return True

3.平衡二叉树：平衡二叉树是一棵二叉树，其可以为空，或满足如下2个性质：①左右子树深度之差的绝对值不大于1。②左右子树都是平衡二叉树。

第一种写法：递归返回判断结果和子节点深度

 1 # 判断二叉树是否为平衡二叉树
 2 # 先判断该节点是否平衡
 3 # 再递归去判断左节点和右节点是否平衡
 4 def process(head):
 5     if head is None:
 6         return True, 0
 7     leftData = process(head.left)
 8     if not leftData[0]:
 9         return False, 0
10     rightData = process(head.right)
11     if not rightData[0]:
12         return False, 0
13     if abs(leftData[1]-rightData[1]) > 1:
14         return False, 0
15     return True, max(leftData[1],rightData[1]) + 1

第二种常见写法：

 1 # 判断二叉树是否为平衡二叉树
 2 # 先判断该节点是否平衡
 3 # 再递归去判断左节点和右节点是否平衡
 4 
 5 # 递归求当前节点的深度
 6 def getdepth(node):
 7     if not node:
 8         return 0
 9     ld = getdepth(node.left)
10     rd = getdepth(node.right)
11     return max(ld, rd) + 1
12 
13 
14 def isB(head):
15     if not head:
16         return True
17     ld = getdepth(head.left)
18     rd = getdepth(head.right)
19     if abs(ld - rd) > 1:
20         return False
21     return isB(head.left) and isB(head.right)