给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

返回 true 。
示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4

返回 false 。

解题思路

对于这个问题，我们可以非常快的写出递归版本。当root为空的时候，我们将None也看成是一棵二叉树，所以返回True。接着我们判断左子树高度和右子树高度差是不是大于1，如果是，那么我们返回False就好啦。如果不是接着递归判断左子树和右子树是不是一棵平衡二叉树。

class Solution:        
    def isBalanced(self, root):
        """ :type root: TreeNode :rtype: bool """
        if not root:
            return True

        def height(node):
            if not node:
                return 0

            return max(height(node.left), height(node.right)) + 1

        if abs(height(root.left) - height(root.right)) > 1:
            return False

        return self.isBalanced(root.left) and self.isBalanced(root.right)

但是如你所见，这个解法有一个很明显的弊端，就是我们在每次求height的时候有大量的重复运算，我们怎么可以避免这种重复运算呢？或者说我们有什么办法在遍历一遍树（求一次height）的过程中就可以得到答案呢？我们希望当左右子树中存在不平衡的时候就可以提前停止。

class Solution:        
    def isBalanced(self, root):
        """ :type root: TreeNode :rtype: bool """
        def height(node):
            if not node:
                return 0

            left = height(node.left)
            right = height(node.right)
            if left == -1 or right == -1 or abs(left - right) > 1:
                return -1

            return max(left, right) + 1
        
        return height(root) != -1

上面这种解法非常的巧妙，当树出现不平衡的时候，我们令树的高度是-1。

同样的，对于可以用递归解决的问题，我们都应该思考一下怎么可以通过迭代去解决。那这个问题怎么通过迭代解决呢？我们可以先通过BFS得到一个list，然后从list的最后一个节点回退到root，并且计算节点的深度差，更新各节点深度。

class Solution:        
    def isBalanced(self, root):
        """ :type root: TreeNode :rtype: bool """
        nodes = [root]
        for node in nodes:
            if node:
                nodes.extend([node.left, node.right])

        depths = {}
        nodes.reverse()
        for node in nodes:
            if node:
                if abs(depths.get(node.left, 0) - depths.get(node.right, 0)) > 1:
                    return False

                depths[node] = max(depths.get(node.left, 0), depths.get(node.right, 0)) + 1

        return True

我们也可以通过前序遍历的方式去更新节点的深度。但是这里的问题和之前的Leetcode 144:二叉树的前序遍历（最优雅的解法！！！）中有一些区别，之前的问题中是输出节点，而我们这里是要更新节点。所以我们不能直接将节点弹出，而是要保留到更新完节点后再弹出。这要怎么做呢？我们可以通过建立一个tuple包含一个seen信息，表示这个节点之前是不是访问过。如果访问过我们再将节点弹出，否则的话再将节点插回去。

class Solution:        
    def isBalanced(self, root):
        """ :type root: TreeNode :rtype: bool """
        stack = list()
        stack.append((root, 0))
        depths = {}
        while stack:
            node, seen = stack.pop()
            if node:
                if not seen:
                    stack.extend([(node, 1), (node.right, 0), (node.left, 0)])
                if abs(depths.get(node.left,0) - depths.get(node.right,0)) > 1:
                    return False
                depths[node] = max(depths.get(node.left,0), depths.get(node.right,0)) + 1

        return True

依照这种思路，我们也可以写出中序遍历和后序遍历的版本。这个问题还没有结束，它还能延伸出这样的问题：如何判断完全二叉树？如何判断满二叉树？我们由前面的问题 Leetcode 222：完全二叉树的节点个数（最详细的解法！！！）知道了完全二叉树的定义

在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

递归实现：

我们知道这样的两个性质，如果我们将root.index从0开始计算的话

• 左孩子=2*i + 1
• 右孩子=2*i + 2

基于这个性质，我们可以先计算节点的个数，然后每个节点的index是不是>=len(tree)，如果是的话，那么自然就返回False，直到所有节点都访问完。

class Solution:  
    def _isCompleteBT(self, root, index, num):
        if not root:
            return True
        
        if index >= num:
            return False
        return self._isCompleteBT(root.left, index*2 + 1, num) and self._isCompleteBT(root.left, index*2 + 2, num)
    
    def isCompleteBT(self, root):
        """ :type root: TreeNode :rtype: bool """
        def countNodes(node):
            if not node:
                return 0
            return 1+ countNodes(node.left) + countNodes(node.right)
        
        num = countNodes(root)
        return self._isCompleteBT(root, 0, num)     
        

迭代实现：

我们可以通过BFS遍历整棵二叉树，对于每个节点我们要做这样的判断

• 左孩子为空，右孩子也必须为空
• 左右孩子都为空或者左孩子不为空而右孩子为空，那么接下来要遍历的节点都必须是叶子节点

class Solution:        
    def isCompleteBT(self, root):
        """ :type root: TreeNode :rtype: bool """
        if not root:
            return True
        
        queue = [root]
        flag = False
        while queue:
            node = queue.pop(0)
            if node.left:
                if flag:
                    return False
                queue.append(node.left)
            else:
                flag = True
                
            if node.right:
                if flag:
                    return False
                queue.append(node.right)
            else:
                flag = True
                
        return True

如何判断满二叉树呢？

递归实现：

主要分成这样几种情况：

• root空，True
• root非空，root.left和root.right都为空，True
• root非空，root.left和root.right都不为空，递归下去
• root非空，root.left为空root.right不为空，root.left不为空root.right为空，False

class Solution:        
    def isFullBT(self, root):
        """ :type root: TreeNode :rtype: bool """
        if not root:
            return True
        
        if not root.left and not root.right:
            return True
        
        if root.left and root.right:
            return self.isFullBT(root.left) and self.isFullBT(root.right)
        
        return False

递归实现：

计算树的节点个数num_nodes和树的深度depth。然后通过depth计算出节点数，比较二者是否相同。

class Solution:        
    def isFullBT(self, root):
        """ :type root: TreeNode :rtype: bool """
        def countNodes(node):
            if not node:
                return 0
            return 1+ countNodes(node.left) + countNodes(node.right)
        
        def height(node):
            if not node:
                return 0
            return max(height(node.left), height(node.right)) + 1
        
        num_nodes = countNodes(root)
        depth = height(root)
        return True if 2**depth - 1 == num_nodes else False

至此，这个问题告一段落了。一个Easy的问题，不知不觉就被我们展开成了一个不小的问题QAQ。。。。但是

我们能否将height和countNodes合并到一块去呢？这似乎是一个有意思的问题。好吧，就这样吧！！！大家可以想一想。

我将该问题的其他语言版本添加到了我的GitHub Leetcode

如有问题，希望大家指出！！！