代码随想录算法训练营第十五天｜110. 平衡二叉树、257. 二叉树的所有路径、404. 左叶子之和、222. 完全二叉树的节点个数

记录路径，回溯法初探，回溯法最重要的回溯的时候在哪里把记录的东西删除掉。只有在增加了元素之后才需要删除元素，那么就要搞清楚在什么情况才会增加元素。

110. 平衡二叉树

leetcode 110. 平衡二叉树
代码随想录

这个方法比之前java写的方法有优化，就是只有递归一次，java的方法是需要去递归所有的子节点的，时间复杂降低了不止一点点。

class Solution:
    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if root == None:
            return True
        def depth(root): 
            if root == None:
                return 0
            leftDepth = depth(root.left)
            rigthDepth = depth(root.right)
            if leftDepth == -1 or rigthDepth == -1 or abs(leftDepth - rigthDepth) > 1:
                return -1
            return max(leftDepth, rigthDepth) + 1
        return depth(root) != -1
        

class Solution {
    public int depth (TreeNode root) {
        if(root == null) {
            return 0;
        }
        return Math.max(depth(root.left), depth(root.right)) + 1;
    }
    public boolean isBalanced(TreeNode root) {
        if(root == null){
            return true;
        }
        int left_depth = depth(root.left);
        int right_depth = depth(root.right);
        if( Math.abs(left_depth - right_depth) > 1) {
            return false;
        }
        return isBalanced(root.left) && isBalanced(root.right);
    }
}

257. 二叉树的所有路径

leetcode 257. 二叉树的所有路径
代码随想录

回溯的时候什么时候pop是一件技术活

class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        path = []
        res = []
        def test(root,path):
            path.append(str(root.val))
            if root.left == None and root.right == None:
                res.append('->'.join(path))
                return
            if root.left != None:
                test(root.left, path)
                path.pop()
            if root.right != None:
                test(root.right, path)
                path.pop()
        test(root, path)
        return res

404. 左叶子之和

leetcode 404. 左叶子之和
代码随想录

注意左叶子节点的定义

class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        if root == None:
            return 0
        if root.left == None and root.right == None:
            return 0
        leftSum = self.sumOfLeftLeaves(root.left)
        if root.left and root.left.left == None and root.left.right == None:
            leftSum = root.left.val
        rightSum = self.sumOfLeftLeaves(root.right)
        return leftSum + rightSum

222. 完全二叉树的节点个数

leetcode 222. 完全二叉树的节点个数
代码随想录

class Solution:
    def countNodes(self, root: Optional[TreeNode]) -> int:
        def travese(root):
            if root == None:
                return 0
            leftCount = travese(root.left)
            rightCount = travese(root.right)
            return leftCount + rightCount + 1
        return travese(root)