代码随想录算法训练营第18天 |、112. 路径总和、113. 路径总和 II、106. 从中序与后序遍历序列构造二叉树、105. 从前序与中序遍历序列构造二叉树

总结

1.在利用前序遍历求解问题时，会用到回溯，有机会总结一下，回溯的呈现方式就是pop()。
2.

题目链接：

自己想

1.递归三部曲：返回值不仅有最后的值，还得有深度，所以返回值是两个，可以考虑开辟一个新的函数。
2.终止条件：我理解的就是当一个节点的左右子树都为空时候，就可以结束了（这和以前root 为空有什么不一样的地方呢？）
3.如何判断为最左最深的子节点呢？->不会

1.没有理解最底层，最左边的节点是什么意思

看完题解

1.看到求深度，应该考虑一下前序遍历
2.同时，如何明确最深，最左呢，就是在终止条件判断一下，而且由于是前序遍历，所以能保证在一颗树左右节点都有值的情况下，返回的是最左。

完整代码

在这里插入代码片

112. 路径总和

题目链接：

leecode-路径总和

自己想

1.返回值为true ，false，那么就要再开辟一个函数，衔接性->
2.对于新开辟的函数的返回值应该为sum，然后在主函数中判断该值是否为目标值
3.终止条件就是：not root.left and not root.right
4.单层递归逻辑：明确一下递归遍历顺序：最好的理解应该是前序，但是我在写这个前序时候，我明确终止条件后，然后怎么将终止条件返回给主函数呢？这就和那个平衡二叉树一样的问题，我还得在调用这个函数的时候做一个终止条件return的判断

具体来说：

看完题解

解答上面的问题：
1.是需要衔接性，因此开辟了一个函数，完成

        if self.traversal(root):
            return True
        else:
            return False

2.其实可以不用返回sum，直接返回true or False即可
3.没错：终止条件就是，但是终止之后需要雨targetsum去比较，选择是否返回true or false
4.调用这个函数的时候做一个终止条件return的判断，但是还断了一步，比如在递归中，进行一次递归要有返回值的时候，也需要做判断呀，加上这个就对了：

       if self.traversal(root.right):
            return True

完整代码

# 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 __init__(self):
        self.target = 0
        self.list_ = []
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:

        self.target = targetSum
        if self.traversal(root):
            return True
        else:
            return False


    def traversal(self,root):
        if not root:
            return 0
        self.list_.append(root.val)
        if not root.left and not root.right:
            
            total = sum(self.list_)
            if total == self.target:
                return True
            else:
                return False
                

        if root.left:
            # list_.append(root.left.val)
            if self.traversal(root.left):
                return True
            self.list_.pop()

        if root.right:
            # list_.append(root.right.val)
            if self.traversal(root.right):
                return True
            self.list_.pop()
        
        return False

113. 路径总和 II

题目链接：

leecode-路径总和ii

自己想

1.与上一问差不多，直接就将符合条件的路径保存到一个全局变量的列表里即可，但是出现了错误：具体错误就是我在将路径添加到最后返回列表时出现了结果返回不对的情况，但是在将路径打印出来看是对的

看完题解

1.解决上面问题，不了解python内部机制问题，导致出错
具体原因：
在Python中，self.result.append(self.path[:]) 和 self.result.append(self.path) 的区别在于 self.path[:] 使用了 Python 中的切片操作符，它会创建一个新的列表，其中包含 self.path 中的所有元素。而 self.result.append(self.path) 只是将 self.path 引用的列表添加到 self.result 中，只会对 path 的修改也会作用到 result 中已经存储的结果元素中。

完整代码

# 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 __init__(self):
        self.target = 0
        self.path = []
        self.result = []
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        self.target = targetSum
        if not root:
            return []
        self.traversal(root)
        # print(self.result)
        return self.result


    def traversal(self,root):

        self.path.append(root.val) 
        if not root.left and not root.right:
            total = sum(self.path)
            if total == self.target:
                # print(self.path)#在这步可以调试出来答案，但是在print(self.result)时候却没有返回正确答案,我理解我初始化后就是将result和path设置为全局变量了
                self.result.append(self.path[:])



            
        if root.left:
            self.traversal(root.left)
            self.path.pop()
        if root.right:
            self.traversal(root.right)
            self.path.pop()

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

题目链接：

leecode-构造二叉树

自己想

1.看返回时树根节点，肯定要形成链表。
2.如何明确返回条件，是当root.left 为空，还是root 为空呢？->我先尝试了root.left与root.right为空，发现不太合理，所以使用了root为空

看完题解

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 len(postorder) != 0:
            root = TreeNode(postorder[-1])
        else: 
            return None

        # print(postorder)
        # print(inorder)
        index = inorder.index(postorder[-1])
        lefttree_inorder = inorder[0:index]
        righttree_inorder = inorder[index+1:]
        lefttree_postorder = postorder[0:index]
        righttree_postorder = postorder[index:index + len(righttree_inorder)]
        root.left = self.buildTree(lefttree_inorder,lefttree_postorder)
        root.right = self.buildTree(righttree_inorder,righttree_postorder)


        return root
        

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

题目链接：

leecode-遍历二叉树

完整代码

# 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 len(preorder) != 0:
            root = TreeNode(preorder[0])
        else:
            return None
        
        index = inorder.index(preorder[0])
        leftinorder = inorder[0:index]
        rightinorder  = inorder[index+1:]

        leftpreorder = preorder[1:1+len(leftinorder)]
        rightpreorder = preorder[1+len(leftinorder):]

        root.left = self.buildTree(leftpreorder,leftinorder)
        root.right = self.buildTree(rightpreorder,rightinorder)

        return root