常见算法的进阶打怪路程|二叉树 04

513. 找树左下角的值 - 力扣（LeetCode）

##层序
# 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
from collections import deque
class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        que=deque()
        re=0
        if root:
            que.append(root)
        while que:
            size=len(que)
            for i in range(size):
                node=que.popleft()
                if i==0:
                    re=node.val
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
        return re

##递归
# 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
from collections import deque
class Solution:
    def qianxu(self,node):
        if not node.left and not node.right:
            if self.dep>self.mxd:
                self.mxd=self.dep
                self.re=node.val
            return 
        if node.left:
            self.dep+=1
            self.qianxu(node.left)
            self.dep-=1
        if node.right:
            self.dep+=1
            self.qianxu(node.right)
            self.dep-=1

    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        self.mxd=float('-inf')
        self.re=0
        self.dep=0
        self.qianxu(root)
        return self.re

112. 路径总和 - 力扣（LeetCode）

# 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 getpath(self,node):
        self.sm+=node.val
        if not node.left and not node.right:
            self.re.append(self.sm)
            return
        if node.left:
            self.getpath(node.left)
            self.sm-=node.left.val
        if node.right:
            self.getpath(node.right)
            self.sm-=node.right.val

    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        self.re=[]
        self.sm=0
        if not root:
            return False
        self.getpath(root)
        return targetSum in self.re

113. 路径总和 II - 力扣（LeetCode）

# 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 getpath(self,node,targetSum):
        self.sm+=node.val
        self.path.append(node.val)
        if not node.left and not node.right:
            if self.sm==targetSum:
                self.re.append(self.path[:])
            return
        if node.left:
            self.getpath(node.left,targetSum)
            self.sm-=node.left.val
            self.path.pop()
        if node.right:
            self.getpath(node.right,targetSum)
            self.sm-=node.right.val
            self.path.pop()

    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        self.re=[]
        self.path=[]
        self.sm=0
        if not root:
            return self.re
        self.getpath(root,targetSum)
        return self.re

106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

# 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]) -> Optional[TreeNode]:
        if not postorder:
            return None
        root = TreeNode(val=postorder[-1])
        if len(postorder)==1:
            return root
        idx=inorder.index(root.val)
        print(1111)
        lfin,rgin=inorder[:idx],inorder[idx+1:]
        lfpo,rgpo=postorder[:len(lfin)],postorder[len(lfin):-1]
        root.left=self.buildTree(lfin,lfpo)
        print(222)
        root.right=self.buildTree(rgin,rgpo)
        return root

105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

# 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]) -> Optional[TreeNode]:
        if not preorder:
            return None
        root=TreeNode(val=preorder[0])
        if len(preorder)==1:
            return root
        idx=inorder.index(root.val)
        inlf,inrg=inorder[:idx],inorder[idx+1:]
        polf,porg=preorder[1:len(inlf)+1],preorder[len(inlf)+1:]
        root.left=self.buildTree(polf,inlf)
        root.right=self.buildTree(porg,inrg)
        return root