代码随想录算法训练营第十八日｜LC513, 112, 106

LC513:

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        queue = deque()
        if root:
            queue.append(root)
        res = 0
        while queue:
            for i in range(len(queue)):
                if i == 0: #i==0就是每一层的第一个节点的值 也就是最左侧节点
                    res = queue[i].val
                cur = queue.popleft()
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return res

迭代比递归要好理解的多！

LC 112:

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False
        return self.traversal(root, targetSum-root.val)

    def traversal(self, root, target):
        if root.left == None and root.right == None and target == 0:
            return True
        if root.left == None and root.right == None and target != 0:
            return False
        if root.left != None:
            target -= root.left.val
            if (self.traversal(root.left, target)):
                return True
            target += root.left.val
        if root.right != None:
            target -= root.right.val
            if (self.traversal(root.right, target)):
                return True
            target += root.right.val
        return False

单层循环逻辑：也就是左子树和右子树的遍历方式，是不是应该直接self.traversal(root.left,target)?那么这里需不需要返回值呢？答案是肯定要的。因为我们只遍历了一条，其他的需不需要返回呢？所以递归了之后需要返回true，然后我们开始回溯.

LC106:

class Solution:
    def buildTree(self, inorder: List[int], postorder: List[int]) -> Optional[TreeNode]:
        if not postorder:
            return None #递归终止条件
        root_val = postorder[-1]
        root = TreeNode(root_val) #后序遍历的最后一个就是当前的中间节点.
        separator_index = inorder.index(root_val) # 切割找点
        inorder_left = inorder[:separator_index]
        inorder_right = inorder[separator_index + 1:] #切割inorder数组. 得到inorder数组的左,右半边. 
        #切割postorder数组. 得到postorder数组的左,右半边.
        #序数组大小一定跟后序数组大小是相同的.
        postorder_left = postorder[:len(inorder_left)]
        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