leetcode7道树的题目 python

100 相同的树
给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if p == None and q == None:
            return True
        if p == None and q != None:
            return False
        if p != None and q == None:
            return False
        if p.val != q.val:
            return False
        if not self.isSameTree(p.left,q.left):
            return False
        if not self.isSameTree(p.right,q.right):
            return False
        return True


101 对称二叉树
给定一个二叉树，检查它是否是镜像对称的。
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def helper(self, left: TreeNode, right: TreeNode) -> bool:
        if not left and not right:
            return True
        if not left or not right:
            return False
        if left.val != right.val:
            return False
        if not self.helper(left.left, right.right):
            return False
        if not self.helper(left.right, right.left):
            return False
        return True
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        return self.helper(root.left, root.right)
     
104 二叉树最大深度
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        return  1+max(self.maxDepth(root.left), self.maxDepth(root.right))
 
107 二叉树的层次遍历2
class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = []
        stack = [root]
        while len(stack) != 0:
            tmp_list = []
            num = len(stack)
            for i in range(num):
                node = stack.pop(0)
                tmp_list.append(node.val)
                if node.left:
                    stack.append(node.left)
                if node.right:
                    stack.append(node.right)
            res.insert(0,tmp_list)
        return res

108 将有序数组转化为二叉搜素树
限制条件：符合平衡树要求
class Solution:
    def helper(self, nums, left, right) -> TreeNode:
        if left > right:
            return None
        mid = (left+right)//2
        root = TreeNode(nums[(left+right)//2])
        root.left = self.helper(nums, left, mid -1)
        root.right = self.helper(nums, mid+1, right)
        return root
    def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
        root = self.helper(nums, 0, len(nums)-1)
        return root

110 平衡二叉树
判断一颗树是否为平衡二叉树
class Solution:
    def get_height(self, root: TreeNode) -> int:
        if not root:
            return 0
        return 1+ max(self.get_height(root.left),self.get_height(root.right))
    def isSortedTree(self, root: TreeNode) -> bool:
        if not root:
            return True
        if not root.left and root.val < root.left.val:
            return False
        if not root.right and root.val > root.left.val:
            return False
        return True
    def isBalanced(self, root: TreeNode) -> bool:
        if not root:
            return True
        if abs(self.get_height(root.left)-self.get_height(root.right))>1:
            return False
        if not self.isBalanced(root.left):
            return False
        if not self.isBalanced(root.right):
            return False
        return True

111 二叉树的最小深度
class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        if not root.left and root.right:
            return self.minDepth(root.right)+1
        if not root.right and root.left:
            return self.minDepth(root.left)+1
        if not root.left and not root.right:
            return 1
        return  1+min(self.minDepth(root.left),