算法随想录第18天

找树左下角的值

  本题最直观的解法就是用层序遍历，找到最深层的最左边的节点元素。用递归的解法，核心思想就是寻找深度最大的叶子节点，且只在最大深度更新时更新结果值(这样就保证取到的是深度最深的最左边的节点元素)。同时，深度进行传参时，递归之后要进行回溯，以便进行同层另一颗子树的遍历。

解法一（递归）：

class Solution(object):
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        self.max_depth = float('-inf')
        self.result = None
        depth = 0
        self.traver(root,depth)
        return self.result
    def traver(self,node,depth):  # 寻找深度最大的叶子节点
        if not (node.left or node.right): # 不遍历至叶子节点则一直递归至叶子节点再做深度的判断以及赋值
            if self.max_depth < depth:
                self.result = node.val
                self.max_depth = depth
            return
        if node.left:
            self.traver(node.left,depth+1)  # 隐藏回溯
        if node.right:
            self.traver(node.right,depth+1)
        # 不隐藏回溯的版本
        # if node.left:
        #     depth += 1
        #     self.traver(node.left,depth)
        #     depth -= 1  
        # if node.right:
        #     depth += 1
        #     self.traver(node.right,depth)
        #     depth -= 1

解法二（层序遍历）：

class Solution(object):
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        queue = collections.deque([root])
        while queue:
            size = len(queue)
            cur = queue.popleft()
            result = cur.val
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
            for _  in range(size-1):
                cur = queue.popleft()
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return result

路径总和（找到一条路径满足要求即可）

class Solution(object):
    def hasPathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: bool
        """
        if not root:
            return False
        self.targetSum = targetSum
        return self.traver(root,root.val)

    def traver(self,node,summ):
        if not (node.left or node.right):
            if summ == self.targetSum:
                return True
            return False
        if node.left:
            if self.traver(node.left,summ+node.left.val):
                return True
        if node.right:
            if self.traver(node.right,summ+node.right.val):
                return True

路径总和（找到所有满足要求的路径）

  传入目标值，在遍历过程中做减去当前节点元素值的操作，可以不用额外构造一个求和的参数，当遍历至叶子节点时目标值减到0则代表该条路径满足条件。

class Solution(object):
    def pathSum(self, root, targetSum):
        """
        :type root: TreeNode
        :type targetSum: int
        :rtype: List[List[int]]
        """
        self.result = []
        if not root:
            return []
        self.traver(root,[root.val],self.result,targetSum-root.val)
        return self.result

    def traver(self,node,path,result,summ):
        if not (node.left or node.right):
            if summ == 0:
                self.result.append(path[:])
            return
        if node.left:
            path.append(node.left.val)
            self.traver(node.left,path,result,summ-node.left.val)
            path.pop()
        if node.right:
            path.append(node.right.val)
            self.traver(node.right,path,result,summ-node.right.val)
            path.pop()

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

• 某个二叉树后序遍历的最后一个元素一定为该二叉树的根节点(子树亦是如此)
• 找到某个中间节点划分中序遍历，左边为左子树中序遍历，右边为右子树中序遍历
    解该题的核心思想就是，根据后序遍历确定中间节点，再根据中间节点确定左右子树的中序遍历，再根据左右子树的中序遍历，确定左右子树的后序遍历。以此迭代直接遍历至叶子节点。

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_left = inorder[:separator_idx]
        inorder_right = inorder[separator_idx+1:]
        # 第五步：根据左右子树的中序遍历得到切割后序遍历得到左右子树的后序遍历
        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