算法工程师重生之第十四天（找树左下角的值 路径总和 从中序与后序遍历序列构造二叉树 ）

参考文献 代码随想录

一、找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

输入: root = [2,1,3]
输出: 1

示例 2:

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

提示:

• 二叉树的节点个数的范围是 [1,104]
• -231 <= Node.val <= 231 - 1 

问题分析

        使用层次遍历，然后取最后一层的第一个元素

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        #  层次遍历
        from collections import deque
        queen = deque()
        if root:
            queen.append(root)
        else:
            return root
        result = []
        while queen:
            n = len(queen)
            tmp = []
            for i in range(n):
                cur =  queen.popleft()
                tmp.append(cur.val)
                if cur.left:
                    queen.append(cur.left)
                if cur.right:
                    queen.append(cur.right)
            result.append(tmp)
        return result[-1][0]

递归遍历 

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def __init__(self):
        self.result = float("-inf")
        self.value = 0
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        # 递归
        
        self.dfs(root,  1)
        return self.value
    def dfs(self, cur,  depth):
        if not cur.left and not cur.right:   # 记录每次可能成为最大深度对应的值
            if depth > self.result:
                self.result = depth
                self.value = cur.val
        if not cur:
            return 0
        if cur.left:
            self.dfs(cur.left, depth + 1)
        if cur.right:
            self.dfs(cur.right,  depth +  1)

二、路径总和 

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

• 树中节点的数目在范围 [0, 5000] 内
• -1000 <= Node.val <= 1000
• -1000 <= targetSum <= 1000

递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def __init__(self):
        self.result = []
    def hasPathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: bool
        """
        # 使用的是前序遍历
        if root:
            self.dfs(root, root.val)
        else:
            return False
        return targetSum in self.result
    def dfs(self,  cur, sumN):
        if not cur:
            return
        if not cur.left and not cur.right:
            self.result.append(sumN)
        if cur.left:
            self.dfs(cur.left, sumN + cur.left.val)
        if cur.right:
            self.dfs(cur.right, sumN + cur.right.val)

迭代

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def __init__(self):
        self.result = []
    def hasPathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: bool
        """
        # 使用的是前序遍历
        from collections import deque
        stack = deque() # 通过保存 的元素是一个元组（指针，路径之和）
        if root:
            stack.append((root, root.val))
        else:
            return False
        while stack:
            cur, value = stack.pop()
            if not cur.left and not  cur.right and value == targetSum:
                return True 
            if cur.left:
                stack.append((cur.left, cur.left.val + value))
            if cur.right:
                stack.append((cur.right, cur.right.val + value))
        return False

路径总和 II

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

• 树中节点总数在范围 [0, 5000] 内
• -1000 <= Node.val <= 1000
• -1000 <= targetSum <= 1000

递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def __init__(self):
        self.result = []
    def pathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: List[List[int]]
        """
          # 使用的是前序遍历
        if root:
            self.dfs(root, [root.val], targetSum, root.val)
        else:
            return []
        return self.result
    def dfs(self,  cur, sumN, targetSum, tmpSum):
        if not cur:
            return
        if not cur.left and not cur.right:
            if tmpSum == targetSum:
                self.result.append(sumN)
        if cur.left:
            self.dfs(cur.left, sumN + [cur.left.val],  targetSum, tmpSum + cur.left.val)
        if cur.right:
            self.dfs(cur.right, sumN + [cur.right.val], targetSum, tmpSum + cur.right.val)
        

迭代

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def __init__(self):
        self.result = []
    def pathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: List[List[int]]
        """
          # 使用的是前序遍历
        from collections import deque
        stack = deque() # 通过保存 的元素是一个元组（指针，数组）
        r = []
        if root:
            stack.append((root, [root.val]))
        else:
            return r

        while stack:
            cur, li = stack.pop()
            if not cur.left and not cur.right and sum(li) ==  targetSum:
                r.append(li)
            if cur.left:
                stack.append((cur.left,  li + [cur.left.val]))
            if cur.right:
                stack.append((cur.right, li + [cur.right.val]))
        return r

三、从中序与后序遍历序列构造二叉树

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

示例 2:

输入：inorder = [-1], postorder = [-1]
输出：[-1]

提示:

• 1 <= inorder.length <= 3000
• postorder.length == inorder.length
• -3000 <= inorder[i], postorder[i] <= 3000
• inorder 和 postorder 都由 不同 的值组成
• postorder 中每一个值都在 inorder 中
• inorder 保证是树的中序遍历
• postorder 保证是树的后序遍历

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def buildTree(self, inorder, postorder):
        """
        :type inorder: List[int]
        :type postorder: List[int]
        :rtype: TreeNode
        """
        if not postorder:
            return None
        # 找切割的下标
        var = postorder[-1]
        
        
        root = TreeNode(var)  # 创建数

        indexN = inorder.index(var)

        # 切割中序
        inorderLeft = inorder[:indexN] #根据在后序遍历找的切割
        inorderRight = inorder[indexN + 1:]

        #切割后序
        postorderLeft = postorder[:len(inorderLeft)]
        postorderRight = postorder[len(inorderLeft): len(postorder) - 1]

        root.left = self.buildTree(inorderLeft, postorderLeft)
        root.right = self.buildTree(inorderRight, postorderRight)

        return root

从前序与中序遍历序列构造二叉树

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

• 1 <= preorder.length <= 3000
• inorder.length == preorder.length
• -3000 <= preorder[i], inorder[i] <= 3000
• preorder 和 inorder 均 无重复 元素
• inorder 均出现在 preorder
• preorder 保证 为二叉树的前序遍历序列
• inorder 保证 为二叉树的中序遍历序列

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        if not preorder:
            return

        val = preorder[0]
        indexN = inorder.index(val)

        root = TreeNode(val)

        # 切割中序
        inorderLeft = inorder[:indexN]
        inorderRight = inorder[indexN + 1:]

        # 切割前序
        preorderLeft = preorder[1: 1 + len(inorderLeft)]
        preorderRight = preorder[len(inorderLeft) + 1: ]
        
        root.left  = self.buildTree(preorderLeft, inorderLeft)
        root.right = self.buildTree(preorderRight, inorderRight)
        return root