树——递归思想

1.递归

树要么是空树，要么有两个指针，每个指针指向一棵树。树是一种递归结构，很多树的问题可以使用递归来处理。

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

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        if root == None:
            return True
        if abs(self.height(root.left)-self.height(root.right))<=1:
            return self.isBalanced(root.left) and self.isBalanced(root.right)
        else:
            return False
            

    def height(self, root):
        if root == None:
            return 0

        left_height = self.height(root.left) + 1
        right_right = self.height(root.right) + 1
        return max(left_height, right_right)

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        self.ans = 1
        self.height(root)
        return self.ans - 1

    def height(self,root):
        if root is None:
            return 0
        left = self.height(root.left)
        right = self.height(root.right)
        self.ans = max(self.ans, left + right + 1)
        return max(left, right) + 1

函数里面的self.ans相当于类里面的全局变量，其他函数也可以引用
记得存下ans，因为最长的可能在某一个子树里面，而不是根节点直接左子树加上右子树

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if root is None:
            return 
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def mergeTrees(self, root1: TreeNode, root2: TreeNode) -> TreeNode:
        root = TreeNode()
        if root1 is None and root2 is None:
            return
        if root1 is None:
            return root2
        elif root2 is None:
            return root1
        else:
            root.val = root1.val + root2.val
            root.left = self.mergeTrees(root1.left, root2.left)
            root.right = self.mergeTrees(root1.right, root2.right)
        return root

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def hasPathSum(self, root: TreeNode, targetSum: int) -> bool:
        if root is None:
            return False
        if root.left is None and root.right is None and root.val == targetSum:
            return True
        return self.hasPathSum(root.left, targetSum-root.val) or self.hasPathSum(root.right, targetSum-root.val) 

路径不一定以 root 开头，也不一定以 leaf 结尾，但是必须连续。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> int:
        if root is None:
            return 0
        return self.helper(root,sum)+self.pathSum(root.left,sum)+self.pathSum(root.right,sum)

    def helper(self, root, sum):
        if root is None:
            return 0
        res = 0
        if root.val == sum:
            res = res + 1
        res = res + self.helper(root.left,sum-root.val) + self.helper(root.right,sum-root.val)
        return res

class Solution:
    def isSubtree(self, s: TreeNode, t: TreeNode) -> bool:
        def helper(root1, root2):
            if root1 is None and root2 is None:
                return True
            if root1 is None or root2 is None:
                return False

            if root1.val != root2.val:
                return False
            else:
                return helper(root1.left, root2.left) and helper(root1.right, root2.right)
        

        if s is None or t is None:
            return False
        
        return helper(s,t) or self.isSubtree(s.left,t) or self.isSubtree(s.right,t) 

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:

        def sys(root1, root2):
            if root1 is None and root2 is None:
                return True
            if root1 is None or root2 is None:
                return False
            if root1.val != root2.val:
                return False
            return sys(root1.left, root2.right) and sys(root1.right, root2.left)
        
        if root is None:
            return True
        return sys(root.left, root.right)

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if root is None:
            return 0

        if root.left is None and root.right is None:
            return 1
        
        if root.left is None:
            return self.minDepth(root.right) + 1
        
        elif root.right is None:
            return self.minDepth(root.left) + 1

        else:
             return min(self.minDepth(root.right), self.minDepth(root.left)) + 1

class Solution:
    def sumOfLeftLeaves(self, root: TreeNode) -> int:
        if root is None:
            return 0

        left = root.left
        right = root.right

        if left and left.left is None and left.right is None:
            return left.val + self.sumOfLeftLeaves(left) + self.sumOfLeftLeaves(right)
        else:
            return self.sumOfLeftLeaves(left) + self.sumOfLeftLeaves(right)

class Solution:
    def longestUnivaluePath(self, root: TreeNode) -> int:
        self.res = 0
        self.helper(root)
        return self.res

    def helper(self, root):
        
        if root is None:
            return 0
        
        left = self.helper(root.left)
        right = self.helper(root.right)
        left_tmp = 0
        right_tmp = 0
        if root.left and root.left.val == root.val:
            left_tmp = left + 1
        if root.right and root.right.val == root.val:
            right_tmp = right + 1

        self.res = max(self.res, left_tmp + right_tmp)
        return max(left_tmp, right_tmp)

class Solution:
    def findSecondMinimumValue(self, root: TreeNode) -> int:
        # 有子节点就是最小的
        if root is None:
            return -1
        if root.left is None and root.right is None:
            return -1

        leftval = root.left.val
        rightval = root.right.val

        if root.left.val == root.val:
            leftval = self.findSecondMinimumValue(root.left)
        if root.right.val == root.val:
            rightval = self.findSecondMinimumValue(root.right)
        if leftval != -1 and rightval != -1:
            return min(leftval, rightval)
        if leftval == -1:
            return rightval
        return leftval