leetcode【简单】104、二叉树的最大深度 / 110、平衡二叉树 / 543、二叉树的直径

104、二叉树的最大深度

思路：递归

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        l=0
        if not root:
            return 0
        #return max(maxDepth(root.left),maxDepth(root.right))+1
        left=self.maxDepth(root.left)
        right=self.maxDepth(root.right)
        l=max(left,right)+1
        return l

class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        int left=maxDepth(root.left);
        int right=maxDepth(root.right);
        int l=Math.max(left,right)+1;
        return l;
    }
}

110、平衡二叉树

思路：改进，递归计算节点深度的时候，顺便判断是否平衡，不平衡就退出

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def height(root):
            if not root:
                return 0
            lefth=height(root.left)
            righth=height(root.right)
            #如果不平衡就返回-1
            if lefth==-1 or righth==-1 or abs(lefth-righth)>1:
                return -1
            #平衡就返回当前深度
            return max(lefth,righth)+1

        return height(root)>=0

class Solution {
    public boolean isBalanced(TreeNode root) {
        return dfs(root)>-1;
    }
    public int dfs(TreeNode root){
        if(root==null) return 0;
        int lefth=dfs(root.left);
        int righth=dfs(root.right);
        if(lefth<0 || righth<0 || Math.abs(lefth-righth)>1){
            return -1;
        }
        return Math.max(lefth,righth)+1;
    }
}

543、二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

思路：

注意：不一定穿过根节点
不能直接：直径=左子树高度+右子树高度
应当把每个节点都当作root，每次都计算此时的直径，共同维护一个此时的最大直径

错误：7

正确：8

递归公式：
直径=max（left直径，right直径，left高度+right高度）

class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        maxd=[0]
        def dfs(root):
            if not root:
                return 0
            left=dfs(root.left)
            right=dfs(root.right)
            
            maxd[0]=max(maxd[0],left+right)#只增加了判断最大直径

            return max(left,right)+1#正常返回树的高度
        dfs(root)
        return maxd[0]

class Solution {
    int res;
    public int diameterOfBinaryTree(TreeNode root) {
        dfs(root);
        return res;
    }
    public int dfs(TreeNode root){
        if(root==null) return 0;
        int lefth=dfs(root.left);
        int righth=dfs(root.right);
        res=Math.max(res,lefth+righth);
        return Math.max(lefth,righth)+1;
    }
}