LeetCode: Balanced Binary Tree 解题报告

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 depth of the two subtrees of every node never differ by more than 1.

Show Tags

SOLUTION 1:

使用inner Class来解决

 1 // Solution 1:

 2     public boolean isBalanced1(TreeNode root) {

 3         return dfs(root).isBalanced;

 4     }

 5     

 6     // bug 1: inner class is like:  "public class ReturnType {", no ()

 7     public class ReturnType {

 8         boolean isBalanced;

 9         int depth;

10         

11         ReturnType(int depth, boolean isBalanced) {

12             this.depth = depth;

13             this.isBalanced = isBalanced;

14         }

15     }

16     

17     public ReturnType dfs(TreeNode root) {

18         ReturnType ret = new ReturnType(0, true);

19         

20         if (root == null) {

21             return ret;

22         }

23         

24         ReturnType left = dfs(root.left);

25         ReturnType right = dfs(root.right);

26         

27         ret.isBalanced = left.isBalanced 

28                          && right.isBalanced 

29                          && Math.abs(left.depth - right.depth) <= 1;

30                          

31         // bug 2: remember to add 1( the root depth )                 

32         ret.depth = Math.max(left.depth, right.depth) + 1;

33         

34         return ret;

35     }

View Code

SOLUTION 2:

将 get depth函数提出

 1 // Solution 2:

 2     public boolean isBalanced(TreeNode root) {

 3         if (root == null) {

 4             return true;

 5         }        

 6         

 7         return isBalanced(root.left) && isBalanced(root.right)

 8             && Math.abs(getDepth(root.left) - getDepth(root.right)) <= 1;

 9     }

10     

11     public int getDepth(TreeNode root) {

12         if (root == null) {

13             return 0;

14         }

15         

16         return Math.max(getDepth(root.left), getDepth(root.right)) + 1;

17     }

View Code

SOLUTION 3:

leetcode又加强了数据，solution 2对于一条单链过不了了。所以主页君加了一点优化，当检测到某个子节点为null时，求另一个子树的depth时，及时退出，这

样就不会产生getdepth太深的问题：

 1 // Solution 2:

 2     public boolean isBalanced(TreeNode root) {

 3         if (root == null) {

 4             return true;

 5         }

 6         

 7         boolean cut = false;

 8         if (root.right == null || root.left == null) {

 9             cut = true;

10         }

11         

12         return isBalanced(root.left) && isBalanced(root.right)

13             && Math.abs(getDepth(root.left, cut) - getDepth(root.right, cut)) <= 1;

14     }

15     

16     public int getDepth(TreeNode root, boolean cut) {

17         if (root == null) {

18             return -1;

19         }

20         

21         if (cut && (root.left != null || root.right != null)) {

22             // if another tree is not deep, just cut and return fast.

23             // Improve the performance.

24             return 2;

25         }

26         

27         return 1 + Math.max(getDepth(root.left, false), getDepth(root.right, false));

28     }

View Code

 

GITHUB:

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/tree/IsBalanced.java