【leetcode刷题班】二叉树题目求解

 

113. 路径总和 II

注意path.copy()，这是因为string是一个不可变类型，它是通过值传递，而list是一个可变类型，它是通过引用传递，如果想要list通过值传递的话，就必须使用copy。

# 1.使用何种数据结构存储遍历路径上的节点？
# 2.在树的前序遍历时做什么？后序遍历时做什么？
# 3.如何判断一个节点为叶节点？当遍历到叶节点时应该做什么？
class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: List[List[int]]
        """
        rs = []
        path = []
        path_value = 0
        if root is None:
            return rs
        # return self.preorder(root,sum,path,path_value,rs) # 是None
        self.preorder(root, sum, path, path_value, rs)
        # 因为Python是引用传值，所以这个时候执行完preorder函数，rs已经改变了
        return rs

    def preorder(self,node,sum,path,path_value,rs):
        # 深度遍历——前序遍历
        if node is None:
            return

        # 此时访问node为前序遍历
        # 遍历一个节点即更新一次路径值
        path.append(node.val)
        path_value += node.val
        # print(path)

        if node.right is None and node.left is None and path_value == sum:
            # print(path)
            # rs.append(path.copy())  # path.copy()leetcode ide无法通过
            rs.append(path[:])
            # print(rs)

        # 此时访问node为中序遍历
        self.preorder(node.left, sum, path, path_value, rs)
        self.preorder(node.right, sum, path, path_value, rs)
        # 此时访问node为后序遍历
        # 遍历完成后，叶子节点出栈

        # 这一块的顺序不知道到底放在哪里？
        # 答：左右子树全部访问完，说明以它为根节点的这颗子树已经访问完了，
        # 以它为根节点的所有可能性都尝试了，然后就换一个结点为根节点呀
        del path[-1]
        path_value -= node.val

函数并列（上）和函数嵌套函数（下）的区别是什么？

class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: List[List[int]]
        """
        self.res = []
        self.total = sum
        def caculate(root,sum,templist):
            if not root:
                return
            if not root.left and not root.right:
                if root.val+sum == self.total:
                    self.res.append(templist+[root.val])
            if root.left:
                caculate(root.left,sum+root.val,templist+[root.val])
            if root.right:
                caculate(root.right,sum+root.val,templist+[root.val])
        caculate(root,0,[])
        return self.res

 还有一种实现方法。。

def pathSum333(self, root, sum):
    """
    :type root: TreeNode
    :type sum: int
    :rtype: List[List[int]]
    """
    result = list()
    if not root:
        return result

    self._pathSum(result, list(), root, sum)
    return result

def _pathSum(self, result, path, node, num):
    if node:
        path.append(node.val)

        if not node.left and not node.right and num == node.val:
            result.append(path.copy())

        self._pathSum(result, path, node.left, num - node.val)
        self._pathSum(result, path, node.right, num - node.val)
        path.pop()

112. 路径总和

 

https://blog.csdn.net/mengni123321/article/details/48213633