Leetcode 110. 平衡二叉树

题目

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

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

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

解答

解法一：多次遍历 O(n^2)

思路简单。

对于每一个结点都需要遍历一下左右子树，找到左右子树高度，然后判断是否符合平衡二叉树条件。

这导致时间复杂度变成 O(n^2) 。

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        if(root == null) return true;
        
        int left = height(root.left);
        int right = height(root.right);
        return Math.abs(left - right) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }
    
    private int height(TreeNode node) {
        if(node == null) return 0;
        return Math.max(height(node.left), height(node.right)) + 1;
    }
}

结果

解法二：一次遍历 O(n)

在获取高度的时候，顺便判断一下是否满足平衡二叉树的条件。

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    class Result {
        int height;
        boolean isBalanced;
        
        Result(int height, boolean isBalanced) {
            this.height = height;
            this.isBalanced = isBalanced;
        }
    }
    
    public boolean isBalanced(TreeNode root) {
        return helper(root).isBalanced;
    }
    
    private Result helper(TreeNode node) {
        if(node == null) {
            return new Result(0, true);
        }
        
        Result left = helper(node.left);
        Result right = helper(node.right);
        if(!left.isBalanced || !right.isBalanced) return new Result(0, false);
        if(Math.abs(left.height - right.height) <= 1) {
            return new Result(Math.max(left.height, right.height) + 1, true);
        }
        
        return new Result(0, false);
    }
}

结果

发现效率提升不大，猜测可能是因为大量 Result 对象的构造导致。可使用全局变量继续优化。

优化代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    boolean res = true;
    public boolean isBalanced(TreeNode root) {
        helper(root);
        return res;
    }
    
    private int helper(TreeNode node) {
        if(node == null) return 0;
        
        int left = helper(node.left);
        int right = helper(node.right);
        if(Math.abs(left - right) > 1) {
            res = false;
            return -2; // 提前结束递归
        }
        
        return Math.max(left, right) + 1;
    }
}

结果

能否不使用全局变量呢？可以。

最终代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        return helper(root) >= 0;
    }
    
    private int helper(TreeNode node) {
        if(node == null) return 0;
        
        int left = helper(node.left);
        int right = helper(node.right);
        if(left >= 0 && right >= 0 && Math.abs(left - right) <= 1) {
            return Math.max(left, right) + 1;
        }
        
        return -1;  // 表明已经不平衡
    }
}

结果