100 -106 无103 我不想写二叉树啊1啊啊啊啊

100，相同的树

前序遍历 先看结构再看值 用flag剪枝

# 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 isSameTree(self, p: TreeNode, q: TreeNode) -> bool:


        flag = True
        def pretran(node1,node2):
            nonlocal flag
            if (node1 != None and node2== None) or (node1 == None and node2!= None):
                flag = False
                return flag
            if node1 == None and node2 == None:
                return 
            if node1.val != node2.val:
                flag = False
                return flag
            pretran(node1.left,node2.left)
            if flag:
                pretran(node1.right,node2.right)
            
        pretran(p,q)
        return flag

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/same-tree/solution/qian-xu-bian-li-xian-kan-jie-gou-zai-kan-m1f3/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

101:对称二叉树 

被大部分人击败 好像不能从根节点开始  但我图省事了 

# 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 isSymmetric(self, root: TreeNode) -> bool:
        flag = True
        def judge(node1,node2):
            nonlocal flag
            if (not node1) and (not node2):
                return flag
            if ( node1 and not node2) or ( node2 and not node1):
                flag = False
                return flag
            if node1.val == node2.val:
                judge(node1.left,node2.right)
                if flag:
                    judge(node1.right,node2.left)
            else:
                flag = False
            return flag
        return judge(root,root)

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/symmetric-tree/solution/you-shi-bei-da-bu-fen-ren-ji-bai-by-yizh-gqbu/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

102： 层序遍历

记录当前层数长度和下层的长度

# 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 levelOrder(self, root: TreeNode) -> List[List[int]]:
        if root == None:
            return []
        que = []
        rel = []
        curlen = 1
        que.append(root)
        while que != []:
            curlev = []
            nextlen = 0
            for i in range(curlen):
                temp = que[0]
                curlev.append(temp.val)
                if temp.left:
                    nextlen += 1
                    que.append(temp.left)
                if temp.right:
                    nextlen += 1
                    que.append(temp.right)
                del que[0]
            curlen = nextlen
            rel.append(curlev[:])
        return rel


作者：yizhu-jia
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/ji-lu-dang-qian-ceng-shu-chang-du-he-xia-sq13/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

 

104  二叉树最大深度

# 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 maxDepth(self, root: TreeNode) -> int:
        def pre(root,depth,maxdep):
            if root:
                if depth>maxdep:
                    maxdep = depth
            else:
                return maxdep
            return max(pre(root.left,depth+1,maxdep),pre(root.right,depth+1,maxdep))
        return pre(root,1,0)

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/solution/zhi-yao-shi-di-gui-kong-jian-jiu-hui-bei-tdmn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

105：前中 构造二叉树 

每次找到前序的第一个节点X在中序的位置I
I前面的 就是X左子树的中序 I后面的就是X右子树的中序
从前序第二个开始数I个 就是X左子树的前序 后面的是X右子树的中序
以此递归构建X的左右子树

# 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 buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        def build(prestart,preend,instart,inend):
            if prestart >= preend:
                return None
            i = 0
            for val in inorder[instart:inend]:
                if val == preorder[prestart]:
                    break
                i += 1
            root = TreeNode(val=preorder[prestart])
            root.left = build(prestart+1,prestart+i+1,instart,instart+i)
            root.right = build(prestart+i+1,preend,instart+i+1,inend)
            return root
        return build(0,len(preorder),0,len(inorder))

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/solution/di-gui-zao-shu-by-yizhu-jia-m3h2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

106  中后构造二叉树 

跟上题一样 

# 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 buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
        def build(poststart,postend,instart,inend):
            if poststart >= postend:
                return None
            i = 0
            for val in inorder[instart:inend]:
                if val == postorder[postend-1]:
                    break
                i += 1
            root = TreeNode(val=postorder[postend-1])
            root.left = build(poststart,poststart+i,instart,instart+i)
            root.right = build(poststart+i,postend-1,instart+i+1,inend)
            return root
        return build(0,len(postorder),0,len(inorder))


作者：yizhu-jia
链接：https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/solution/shi-jian-zai-ci-da-shi-bai-wo-yao-qu-kan-wdkg/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。