注意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()