劍指offer-平衡二叉樹(python和c++）

題目描述

輸入一棵二叉樹，判斷該二叉樹是否是平衡二叉樹。

在這裏，我們只需要考慮其平衡性，不需要考慮其是不是排序二叉樹

思路：

最直接的做法，遍歷每個結點，藉助一個獲取樹深度的遞歸函數，根據該結點的左右子樹高度差判斷是否平衡，然後遞歸地對左右子樹進行判斷。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def IsBalanced_Solution(self, pRoot):
        # write code here
        if pRoot == None:
            return True
        if abs(self.TreeDepth(pRoot.left)-self.TreeDepth(pRoot.right)) > 1:
            return False
        return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)
       
    def TreeDepth(self, pRoot):
        # write code here
        if pRoot == None:
            return 0
        nLeft = self.TreeDepth(pRoot.left)
        nRight = self.TreeDepth(pRoot.right)
        return max(nLeft+1,nRight+1)#(nLeft+1 if nLeft > nRight else nRight +1)

這種做法有很明顯的問題，在判斷上層結點的時候，會多次重複遍歷下層結點，增加了不必要的開銷。如果改爲從下往上遍歷，如果子樹是平衡二叉樹，則返回子樹的高度；如果發現子樹不是平衡二叉樹，則直接停止遍歷，這樣至多隻對每個結點訪問一次。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    res = True
    def IsBalanced_Solution(self, pRoot):
        # write code here
        self.helper(pRoot)
        return self.res
         
    def helper(self,root):
        if not root:
            return 0
        if not self.res : return 1
        left = 1 + self.helper(root.left)
        right = 1 + self.helper(root.right)
        if abs(left-right)>1:
            self.res = False
        return max(left,right)
         
#不要每個節點都去求一次高度，避免重複

c++

class Solution {
public:
    int TreeDepth(TreeNode *pRoot)
{
    if (pRoot == NULL)
        return 0;
    int left = TreeDepth(pRoot->left);
    int right = TreeDepth(pRoot->right);
 
    return (left > right) ? (left + 1) : (right + 1);
}
     
    bool IsBalanced_Solution(TreeNode* pRoot) {
    if (pRoot == NULL)
        return true;
     
    int left = TreeDepth(pRoot->left);
    int right = TreeDepth(pRoot->right);
    int diff = left - right;
    if (diff > 1 || diff < -1)
        return false;
 
    return IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right);
    }
};