LeetCode - 解题笔记 - 110 - Balanced Binary Tree

Solution 1

整体上就是一个递归计算子树高度的过程，同时判断子树的高度平衡情况，如果子树出现不平衡就将信息一直反传回顶部（跳过其他部分的计算），判断状态使用-1。

• 时间复杂度：$O(n)$，其中$n$为输入的树的节点个数，最坏情况下（完全平衡）遍历所有节点有且仅有一次。
• 空间复杂度：$O(n)$，其中$n$为输入的树的节点个数，递归过程中的系统占用，最坏情况下（完全偏树）需要递归$n$层

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isBalanced(TreeNode* root) {
        return this->height(root) != -1;
    }
    
private:
    int height(TreeNode* node) {
        if (node == nullptr) {
            return 0;
        }
        
        auto heightLeft = this->height(node->left);
        if (heightLeft == -1) {
            return -1;
        }
        auto heightRight = this->height(node->right);
        if (heightRight == -1) {
            return -1;
        }
        
        if (abs(heightLeft - heightRight) > 1) {
            return -1;
        } else {
            return max(heightLeft, heightRight) + 1;
        }
    }
};

Solution 2

Solution 1的Python实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        
        def height(node: Optional[TreeNode]) -> int:
            
            if node is None: return 0
            
            heightLeft = height(node.left)
            if heightLeft == -1: return -1
            
            heightRight = height(node.right)
            if heightRight == -1: return -1
            
            if abs(heightLeft - heightRight) > 1:
                return -1
            else:
                return max(heightLeft, heightRight) + 1
            
        return height(root) != -1