数据结构与算法----学习笔记（6）二叉树实战部分4

路径和相关题目

树的求和属于树的题目中比较常见的，因为可以有几种变体，灵活度比较高，也可以考察到对于树的数据结构和递归的理解。

112路径总和
113路径总和 ii
124二叉树中的最大路径和
129求根到叶子节点数字之和
257二叉树的所有路径

---

112路径总和
递归

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root == None:
            return False
        if root.left == None and root.right == None and root.val == targetSum:
            return True

        return self.hasPathSum(root.left,targetSum-root.val) or self.hasPathSum(root.right,targetSum- root.val)

迭代

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if root== None:
            return False
        stack = [(root,targetSum)]
        while stack:
            node,sum = stack.pop()
            if node.left == None and node.right==None and node.val == sum:
                return True
            if node.left:
                stack.append((node.left,sum-node.val))

            if node.right:
                stack.append((node.right,sum-node.val))
        return False

113路径总和 ii

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        self.res = []
        self.helper(root,targetSum,[])

        return self.res

    
    def helper(self,node,sum,temp):
        if node ==None:
            return False
        if node.left == None and node.right == None and node.val == sum:
            temp+=[node.val]
            self.res.append(temp)
        
        self.helper(node.left,sum-node.val,temp+[node.val])
        self.helper(node.right,sum-node.val,temp+[node.val])

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        if root ==None:
            return []
        res = []
        temp = []
        stack = [(root,targetSum,temp)]
        while stack:
            node,sum,temp = stack.pop()
            if node.left == None and node.right== None and node.val == sum:
                temp+=[node.val]
                res.append(temp)

            if node.left:
                stack.append((node.left,sum-node.val,temp+[node.val]))
            if node.right:
                stack.append((node.right,sum-node.val,temp+[node.val]))
        return res 

124二叉树中的最大路径和

class Solution:
    def __init__(self):
        self.maxSum = float("-inf")

    def maxPathSum(self, root: Optional[TreeNode]) -> int:
        def maxGain(node):
            if node ==None:
                return 0
            # 左节点的最大增益
            left_Gain = max(maxGain(node.left),0)
            right_Gain = max(maxGain(node.right),0)

            # 这个结点作为拐弯处的最大增益
            node_gain = left_Gain + node.val + right_Gain
            self.maxSum = max(self.maxSum,node_gain)

            # 该结点可以给父节点带来的最大增益
            return node.val + max(left_Gain,right_Gain)
        maxGain(root)
        return self.maxSum

129求根到叶子节点数字之和

class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        self.res = []
        self.helper(root,0)
        return sum(self.res)
    
    def helper(self,node,nums):
        if node == None:
            return 0
        nums *=10
        nums += node.val

        if node.left == None and node.right == None:
            self.res.append(nums)
        if node.left:
            self.helper(node.left,nums)
        if node.right:
            self.helper(node.right,nums)

class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        if root == None:
            return 0
        stack = [(root,0)]
        res = []
        while stack:
            node,sums = stack.pop()
            sums*=10
            sums+=node.val
            if node.left == None and node.right == None:
                res.append(sums)
            if node.left :
                stack.append((node.left,sums))
            if node.right:
                stack.append((node.right,sums))

        return sum(res)

257二叉树的所有路径

class Solution:
    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        if root == None:
            return None
        res = []
        queue = [(root,'')]
        while queue:
            # temp = ''
            length = len(queue)
            for _ in range(length):
                node,temp = queue.pop(0)
                temp += str(node.val)
                if node.left == None and node.right == None :
                    res.append(temp)

                temp += '->'
                if node.left:
                    queue.append((node.left,temp))
                if node.right:
                    queue.append((node.right,temp))
        return res