LeetCode刷题实战110：平衡二叉树-技术圈

算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选！

今天和大家聊的问题叫做 平衡二叉树，我们先来看题面：

https://leetcode-cn.com/problems/balanced-binary-tree/

Given a binary tree, determine if it is height-balanced.

For this problem, a height-balanced binary tree is defined as:

a binary tree in which the left and right subtrees of every node differ in height by no more than 1.

题意

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

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

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

样例

解题

https://blog.csdn.net/qq_17550379/article/details/82081501

对于这个问题，我们可以非常快的写出递归版本。当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