Day18代码随想录二叉树part05：513.找树左下角的值、112.路径总和、113.路径总和Ⅱ、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树

Day18 二叉树part05

513.找树左下角的值

层次遍历法：相对简单，但是要注意是双端队列deque啊！怎么没几天又把模板忘了quq

# 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 findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        que = deque()
        que.append(root)
        while que:
            res = []
            for i in range(len(que)):
                node = que.popleft()
                res.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            # print(que, res)
        return res[0]

递归法：找深度最大的节点中最左侧的一个

伪代码：这里使用前序、中序或者后序都可以是因为没有对中的处理逻辑，只要保证先左后右一定能先找到最左侧的

int maxDepth = INT_MIN;
int result; // 每次遇到最大深度更新结果
void traversal(root, depth) // depth为当前深度
{
	//终止条件：叶子节点，同时要更新结果
	if(root.left == NULL && root.right == NULL)
	{
		if (depth> max_depth){
			max_depth = depth
			result = root.val
		}
	}
	if(root.left){
		depth ++;
		traversal(root.left, depth);
		depth --;//这里需要回溯，当然这三句也可以写为一句作为传入参数
	}
	if(root.right){
		depth ++;
		traversal(root.right, depth);
		depth --;//这里需要回溯，当然这三句也可以写为一句作为传入参数
	}
}

python递归版本：

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        self.max_depth = float('-inf')
        self.result = None
        self.traversal(root,0)
        return self.result

    def traversal(self, root, depth):
        if root.left is None and root.right is None:
            if depth > self.max_depth:
                self.max_depth = depth
                self.result = root.val
            return
        if root.left:
            self.traversal(root.left, depth+1)
        if root.right:
            self.traversal(root.right, depth+1)

112. 路径总和

递归法思考：

（1）传入参数：当前节点root，目前的结果集value

（2）终止条件：如果正好为目标值，记录result；如果是叶子节点，返回

（3）单层递归步骤：对于当前节点，如果存在left，则traversal(root.left, value(append(root.left))), right也是

自己的第一遍尝试：

class Solution:
    def findway(self, root, value):
        if sum(value) == self.targetSum and not root.left and not root.right:
            self.result = value
            return
        if not root.left and not root.right:
            return 
        if root.left:
            value.append(root.left.val)
            self.findway(root.left, value)
            value.pop()
        if root.right:
            value.append(root.right.val)
            self.findway(root.right, value)
            value.pop()

    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False
        self.targetSum = targetSum
        self.result = None
        self.findway(root, [root.val])
        if self.result is None:
            return False
        else:
            return True

卡哥的思路：

我们不需要遍历所有的节点，只要找到一条合适的路径就逐层向上返回true就可以

（1）传入参数：函数是bool类型返回，当前节点root，目标值count，最后把count减成0

（2）终止条件：如果是叶子节点且count==0，return true；如果是叶子节点且count!=0，return False

（3）单层递归步骤：先求左逻辑，向左递归，count -= node→left→val, 递归traversal(node→left, count)，①如果向左递归返回的是true说明存在路径，return True逐层返回，②如果返回的是False，则回溯count += node→left→val；再向右遍历也是同样的步骤

113.路径总和ii

和刚才一样的代码，就是result变成append了，上一题其实这样写复杂了

class Solution:
    def findway(self, root, value):
        if sum(value) == self.targetSum and not root.left and not root.right:
            self.result.append(value[:])
            return
        if not root.left and not root.right:
            return 
        if root.left:
            value.append(root.left.val)
            self.findway(root.left, value)
            value.pop()
        if root.right:
            value.append(root.right.val)
            self.findway(root.right, value)
            value.pop()

    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        if not root:
            return []
        self.targetSum = targetSum
        self.result = []
        self.findway(root, [root.val])
        return self.result

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

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

举例：

inorder = [9,3,15,20,7]（中序：左中右）
postorder = [9,15,7,20,3]（后序：左右中）
输出：[3,9,20,null,null,15,7]

1. 如果后序数组为空，空节点
2. 后序数组的最后一个元素为root元素：3
3. 寻找中序数组中的这个点作为切割点
4. 切中序数组
5. 切后序数组
6. 递归处理左区间后区间

算法：

• 递归函数的参数和返回值：inorder， postorder，返回node
• 终止：如果后序为空则返回；后序数组的最后一个元素是分割点root，如果后序大小为1说明只有1个节点，return；
• 递归逻辑：遍历中序数组用index记录，找到分割点root的位置，break；切中序数组得到一个左中序数组和一个右中序数组inorder；切后序数组用中序数组的index切后序数组的左区间、右区间；递归处理得到root→left, root→right；return root
• 注意区间：左闭右开，打日志

# 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 None
        new_node = TreeNode(postorder[-1])
        index = 0
        while index<len(inorder):
            if inorder[index] == new_node.val:
                break
            else:
                index+=1
        new_node.left = self.buildTree(inorder[:index], postorder[:index])
        new_node.right = self.buildTree(inorder[index+1:], postorder[index:len(postorder)-1]) # 注意都是左开右闭区间！
        return new_node

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

前序就是数组中的第一个，剩下思路是类似的

# 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 None
        num = preorder[0]
        new_node = TreeNode(num)

        index = 0
        while index<len(preorder):
            if inorder[index] == num:
                break
            else:
                index+=1
        
        new_node.left = self.buildTree(preorder[1:index+1], inorder[:index])
        new_node.right = self.buildTree(preorder[index+1:], inorder[index+1:])
        return new_node