代码随想录算法训练营第18天|513.找树左下角的值 112. 路径总和 113.路径总和ii 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

513. 找树左下角的值 

题目链接：LeetCode - The World's Leading Online Programming Learning Platform

题目链接/文章讲解/视频讲解：代码随想录

解题思路：

层序遍历最后一个列表的第一个数字

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

递归思路不理解。。

路径总和 

题目链接：LeetCode - The World's Leading Online Programming Learning Platform

题目链接/文章讲解/视频讲解：代码随想录

解题思路：

递归的basic condition是当没有左右子树的时候 ，如果此时targetsum被减到了0 则return true 反之return false

递归左边 要注意回溯 先减去当前值 如果递归返回上来是true就继续向上返回 回溯则在递归后加回当前值。

递归右边同理。 

# 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 hasPathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: bool
        """
        if root is None:
            return False
        def isOrNot(root,targetSum):
            if root.left == None and root.right == None:
                if targetSum-root.val == 0:
                    return True
                else: return False
            if root.left:
                targetSum-=root.val
                if isOrNot(root.left,targetSum) is True: return True
                targetSum+=root.val
            if root.right:
                targetSum-=root.val
                if isOrNot(root.right,targetSum) is True: return True
                targetSum+=root.val
            return False
        return isOrNot(root,targetSum)

题目链接：LeetCode - The World's Leading Online Programming Learning Platform

解题思路：

与上面相似 

设置单列表和结果列表

递归的basic condition是当没有左右子树的时候 ，如果此时targetsum被减到了0 就把悬挂的path记录到res中 

递归左边 要注意回溯 先减去当前值并append左子树 递归左子树 回溯则在递归后加回当前值并把path中append的值pop掉。

右边同理

# 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 pathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: List[List[int]]
        """
        if root is None:
            return []
        path=[]
        res=[]
        path.append(root.val)
        def traversal(root, targetSum):
            if root.left is None and root.right is None:
                if targetSum-root.val==0:
                    res.append(path[:])
                else: return
            if root.left:
                targetSum-=root.val
                path.append(root.left.val)
                traversal(root.left,targetSum)
                path.pop()
                targetSum+=root.val
            if root.right:
                targetSum-=root.val
                path.append(root.right.val)
                traversal(root.right,targetSum)
                targetSum+=root.val
                path.pop()
        traversal(root,targetSum)
        return res

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

本题算是比较难的二叉树题目了，大家先看视频来理解。 

106.从中序与后序遍历序列构造二叉树，105.从前序与中序遍历序列构造二叉树 一起做，思路一样的

解题链接：LeetCode - The World's Leading Online Programming Learning Platform

题目链接/文章讲解/视频讲解：代码随想录

解题思路：

第一步 当树为空 则终止 这里看postorder

第二步 找后序遍历的最后一个节点 这个节点是当前的中间节点

第三部 找切割点，切割点是前面postorder最后一个值在inorder里的位置

第四部 切割inorder 以切割点切割氛围左右半边

第五部 切割postorder，postorder的左半边长度要看左inorder的长度 右半边则是剩下的list减掉最后一个树（当前的root）

第六步 递归左右子树

最后return root

# 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
        root=TreeNode(postorder[-1])
        root_index=inorder.index(postorder[-1])
        left_inorder=inorder[0:root_index]
        right_inorder=inorder[root_index+1:]
        left_postorder = postorder[:len(left_inorder)]
        right_postorder = postorder[len(left_inorder): len(postorder) - 1]
        root.left = self.buildTree(left_inorder, left_postorder)
        root.right = self.buildTree(right_inorder, right_postorder)
        return root

前序类似。