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）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。