LeetCode110 Balanced Binary Tree

详细见：leetcode.com/problems/balanced-binary-tree

Java Solution: github

package leetcode;

import tools.TreeNode辅助.TreeNode;

/*
 * 	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.
 */

public class P110_BalancedBinaryTree {
	public static void main(String[] args) {
		
	}
	/*
	 * 	AC
	 * 	1 ms
	 */
	static class Solution {
		boolean isFalse = false;
	    public boolean isBalanced(TreeNode root) {
	    	if (root == null) {
	    		return true;
	    	}
	    	zxwtry_count(root);
	        return ! isFalse;
	    }
	    int zxwtry_count(TreeNode root) {
	    	if (isFalse) {
	    		return 0;
	    	}
	    	if (root == null) {
	    		return 0;
	    	}
	    	int left = zxwtry_count(root.left);
	    	int right = zxwtry_count(root.right);
	    	if (Math.abs(left - right) > 1) {
	    		isFalse = true;
	    	}
	    	return Math.max(left, right) + 1;
	    }
	}
}

C Solution: github

/*
    url: leetcode.com/problems/balanced-binary-tree
    AC 6ms 54.31%
*/

#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

#define bool int

typedef struct TreeNode stn;
typedef struct TreeNode * ptn;


int search(ptn root, int* b) {
    int cut = 0, lc = 0, rc = 0;
    if (root == NULL) return 0;
    lc = search(root->left, b);
    if (! (*b)) return 0;
    rc = search(root->right, b);
    cut = lc - rc;
    if (cut < -1 || cut > 1) *b = 0;
    if (! (*b)) return 0;
    return lc > rc ? lc+1 : rc+1;
}

bool isBalanced(ptn root) {
    int cut = 0, lc = 0, rc = 0, b = 1;
    if (root == NULL) return 1;
    lc = search(root->left, &b);
    if (! b) return 0;
    rc = search(root->right, &b);
    if (! b) return 0;
    cut = lc - rc;
    return cut >= -1 && cut <= 1;
}

Python Solution: github

#coding=utf-8

'''
    url: leetcode.com/problems/balanced-binary-tree
    @author:     zxwtry
    @email:      zxwtry@qq.com
    @date:       2017年4月29日
    @details:    Solution: 82ms 70.51%
'''

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution(object):
    def search(self, n, sign):
        if n == None or sign[0]: return 0
        lc = self.search(n.left, sign)
        rc = self.search(n.right, sign)
        if abs(lc-rc) > 1: sign[0] = True
        return max(lc, rc) + 1
        
    def isBalanced(self, n):
        """
        :type n: TreeNode
        :rtype: bool
        """
        if n == None: return True
        sign = [False]
        lc = self.search(n.left, sign)
        if (sign[0]): return False
        rc = self.search(n.right, sign)
        if (sign[0]): return False
        return abs(lc-rc) < 2