算法训练记录day18

一、513.找树左下角的值

题目

思路

# 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:
        stack = deque([root])
        reselts = []
        while stack:
            reselt = []
            for i in range(len(stack)):
                node = stack.popleft()
                reselt.append(node.val)
                if node.left:
                    stack.append(node.left)
                    
                if node.right:
                    stack.append(node.right)
                    
            reselts.append(reselt)
        return reselts[-1][0]


# 层序遍历 输出时 最后一层的第一个元素

二、112. 路径总和 113.路径总和ii

题目

# 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 hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False
        stack = deque()
        stack.append((root,root.val))
        while stack:
            node,val1 = stack.popleft()
            if not node.left and not node.right and val1==targetSum:
                return True
            if node.left:
                stack.append((node.left,node.left.val + val1))
            if node.right:
                stack.append((node.right,node.right.val + val1))   
        return False

题目2

# 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: Optional[TreeNode], targetSum: int) -> List[List[int]]:     
        if not root:
            return []
        stack = deque()
     
        stack.append((root,root.val,[root.val]))
        results = []
        while stack:
            node,val1,result = stack.popleft()
            if not node.left and not node.right and val1==targetSum:
                results.append(result)
            if node.left:
                stack.append((node.left,node.left.val + val1,result+[node.left.val]))
            if node.right:
                stack.append((node.right,node.right.val + val1,result+[node.right.val]))   
        return results

思路

三、106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

题目1

# 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
        # 1 找到中间节点，建立新二叉树
        root_val = postorder[-1]
        root = TreeNode(root_val)
        # 2 找到在中序的中间节点索引
        root_index = inorder.index(root_val)
        # 3 切分中序
        left_inorder = inorder[:root_index]
        right_inorder = inorder[root_index+1:]
        # 4 切分后序
        left_postorder = postorder[:len(left_inorder)]
        right_postorder = postorder[len(left_inorder):len(left_inorder)+len(right_inorder)]
# 切割时，可以用 [len(left_inorder):len(postorder)-1]
        # 5 递归 按照上述逻辑，再次切分，直到节点为空
        root.left = self.buildTree(left_inorder,left_postorder)
        root.right = self.buildTree(right_inorder,right_postorder)

        return root     # 返回二叉树

思路

题目2

# 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
        # 1 找到根节点，构建二叉树
        root_val= preorder[0]
        root = TreeNode(root_val)
        # 2 找到根节点在中序中的索引
        inorder_index = inorder.index(root_val)
        # 3 切割中序
        left_inorder = inorder[:inorder_index]
        right_inorder = inorder[inorder_index+1:]
        # 4 切割前序
        left_preorder = preorder[1:1+len(left_inorder)]
        right_preorder = preorder[1+len(left_inorder):]
        # 5 递归 重复切割
        root.left = self.buildTree(left_preorder,left_inorder)   #这里数组的顺序不能反
        root.right = self.buildTree(right_preorder,right_inorder)

        return root