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

【参考链接】

513. 找树左下角的值

【注意】

1.用递归的话就就一直向左遍历，但是到最后一个，它未必是最后一行。是要找到树的最后一行的最左边的值。（不一定是指是左孩子）

2.如果使用递归法，如何判断是最后一行呢，其实就是深度最大的叶子节点一定是最后一行。

3.只要是优先遍历左都可以，所以前中后序都可。

4.层序遍历只需要记录最后一行的第一个节点的数值即可。

【代码】

 1.递归遍历中，用一个变量存储最大深度。终止条件：遍历到叶子节点。然后比较当前叶子节点的深度是否比记录最大深度还大，大的话就要更新这个变量。result变量中存储遍历完树最后的最大深度。

2.向左遍历时先判断root.left是否为空，要有回溯过程，要不depth一直在增加，就出现错误。traversal(root.left,depth+1),隐藏回溯的过程在这个递归函数中，depth+1没有改变depth的值。

3.没有中的处理逻辑，只要强调左在右前面就行。

【代码】

# 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
from collections import deque
class Solution(object):
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
    #     #1.递归法+回溯
    #     self.max_depth = float('-inf')
    #     self.result = None #最后左下角的值
    #     self.traversal(root,0) #递归

    #     return self.result

    # def traversal(self, node, depth):
    #     if not node.left and not node.right:#迭代终止条件：达到叶子节点
    #         if depth > self.max_depth:
    #             self.max_depth = depth
    #             self.result = node.val #因为是先遍历最大深度的左节点所以保证result保存的是左下角的值
    #         return

    #     #左
    #     if node.left:#不为空时
    #         depth += 1
    #         self.traversal(node.left, depth)
    #         depth -= 1#回溯
    #     #右
    #     if node.right:
    #         depth += 1
    #         self.traversal(node.right, depth)
    #         depth -= 1
          
          #2.迭代法：队列 #测试用例[1,2,3,4,null,5,6,null,null,7]
        queue = deque([root])
        while queue:
            size = len(queue) #1->2->3->1
            leftmost = queue[0].val #1->2->4->7

            for i in range(size): #1->2->3
                node = queue.popleft() #1->2->3->4->5->6
                if node.left: #2->4->5->7
                    queue.append(node.left) #2->34->45->67
                if node.right: #3->6
                    queue.append(node.right) #23->456
            if not queue:
                return leftmost #7

112. 路径总和

【注意】

1.本题前中后序都可以，无所谓，因为中节点也没有处理逻辑。

2.只要找到一条符合的路径就返回，返回true。参数直接传入目标值，做累减，知道叶子节点时为0，就是要求得的路径。

3.终止条件：遇到叶子节点进行判读是否为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 hasPathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: bool
        """
        if not root:
            return False
        return self.traversal(root, targetSum) #递归
    #1.递归+回溯
    def traversal(self, node, count):
        # 遇到叶子节点，并且计数为0
        if not node.left and not node.right and count==0:
            return True
        if not node.left and not node.right and count!=0:
            return False
        
        #左
        if node.left:
            count -= node.left.val
            if self.traversal(node.right, count):
                return True
            count += node.left.val #回溯
        # 右
        if node.right: 
            count -= node.right.val
            if self.traversal(node.right, count): # 递归，处理节点
                return True
            count += node.right.val # 回溯，撤销处理结果
        
        return False

113. 路径总和 II

【代码】

# 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 = []
        self.path = []
    #1.递归＋回溯
    def traversal(self, node, count):
            if not node.left and not node.right and count == 0: # 遇到了叶子节点且找到了和为sum的路径
                self.result.append(self.path[:])
                return
            if not node.left and not node.right and count != 0: # 遇到叶子节点而没有找到合适的边，直接返回
                return
            #左
            if node.left:
                self.path.append(node.left.val)
                count -= node.left.val
                self.traversal(node.left, count)
                count += node.left.val#回溯
                self.path.pop()

            #右
            if node.right:
                self.path.append(node.right.val) 
                count -= node.right.val
                self.traversal(node.right, count) # 递归
                count += node.right.val # 回溯
                self.path.pop() # 回溯

    def pathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: List[List[int]]
        """
        if not root:
            return self.result
        self.path.append(root.val)# 把根节点放进路径
        self.traversal(root,targetSum-root.val)

        return  self.result

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

【注意】

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 buildTree(self, inorder, postorder):
        """
        :type inorder: List[int]
        :type postorder: List[int]
        :rtype: TreeNode
        """
        # 第一步: 特殊情况讨论: 树为空. (递归终止条件)
        if not postorder:
            return None
        
        # 第二步: 后序遍历的最后一个就是当前的中间节点.
        root_val = postorder[-1]
        root = TreeNode(root_val) #根节点

        # 第三步: 找切割点.
        separator_idx = inorder.index(root_val)

        # 第四步: 切割inorder数组. 得到inorder数组的左,右半边. 左闭右开
        inorder_left = inorder[:separator_idx]
        inorder_right = inorder[separator_idx+1:]

        # 第五步: 切割postorder数组. 得到postorder数组的左,右半边.
        # ⭐️ 重点1: 中序数组大小一定跟后序数组大小是相同的.
        #左闭右开 右开包含下一个区间的一个值
        postorder_left = postorder[:len(inorder_left)] #控制大小一样，用len
        postorder_right = postorder[len(inorder_left):len(postorder)-1]

        # 第六步: 递归
        root.left = self.buildTree(inorder_left,postorder_left)
        root.right = self.buildTree(inorder_right,postorder_right)

        return root

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

【代码】

# 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 None
        
        # 第二步: 前序遍历的第一个就是当前的中间节点.
        root_val = preorder[0]
        root =TreeNode(root_val)

        # 第三步: 找切割点.
        separator_idx = inorder.index(root_val)

        # 第四步: 切割inorder数组. 得到inorder数组的左,右半边.
        inorder_left = inorder[:separator_idx]
        inorder_right = inorder[separator_idx+1:]

        # 第五步: 切割preorder数组. 得到preorder数组的左,右半边.
        # ⭐️ 重点1: 中序数组大小一定跟前序数组大小是相同的.
        preorder_left = preorder[1:1+len(inorder_left)]
        preorder_right = preorder[1+len(inorder_left):]

        # 第六步: 递归
        root.left = self.buildTree(preorder_left,inorder_left)
        root.right = self.buildTree(preorder_right,inorder_right)

        return root