给定一个二叉树和一个数字“S”，找到从根到叶的所有路径，使得每条路径的所有节点值的总和等于“S”

Question

The example below is from a source online and what I'm not sure of is why we need to append to allPaths a new copy of currentPath . I thought that in deleting the last element as we go back up the recursive call stack by doing del currentPath[-1] makes sure that we are not adding the previous path to the new path

class TreeNode:
  def __init__(self, val, left=None, right=None):
    self.val = val
    self.left = left
    self.right = right


def find_paths(root, required_sum):
  allPaths = []
  find_paths_recursive(root, required_sum, [], allPaths)
  return allPaths


def find_paths_recursive(currentNode, required_sum, currentPath, allPaths):
  if currentNode is None:
    return

  # add the current node to the path
  currentPath.append(currentNode.val)

  # if the current node is a leaf and its value is equal to required_sum, save the current path
  if currentNode.val == required_sum and currentNode.left is None and currentNode.right is None:
    allPaths.append(list(currentPath))
  else:
    # traverse the left sub-tree
    find_paths_recursive(currentNode.left, required_sum -
                         currentNode.val, currentPath, allPaths)
    # traverse the right sub-tree
    find_paths_recursive(currentNode.right, required_sum -
                         currentNode.val, currentPath, allPaths)

  # remove the current node from the path to backtrack,
  # we need to remove the current node while we are going up the recursive call stack.
  del currentPath[-1]


def main():

  root = TreeNode(12)
  root.left = TreeNode(7)
  root.right = TreeNode(1)
  root.left.left = TreeNode(4)
  root.right.left = TreeNode(10)
  root.right.right = TreeNode(5)
  required_sum = 23
  print("Tree paths with required_sum " + str(required_sum) +
        ": " + str(find_paths(root, required_sum)))


main()

Answer 1

It is important to realise that during the whole process there is only one currentPath list. It is the one that is created in the initial call:

find_paths_recursive(root, required_sum, [], allPaths)
#                                        ^^---here!

All that happens to that single list is that elements are appended to it, and then deleted from it again (when backtracking). It continually grows and shrinks, grows and shrinks,... throughout its lifetime. But it is the same, single list instance.

If you were to append that list to allPaths without taking a copy, ie like this:

allPaths.append(currentPath)

...then realise that while that list is a member of allPaths , it will be mutated by future append and delete actions on it! Even more: as the above statement is executed again later on:

allPaths.append(currentPath)

... exactly the same list is appended that is already in allPaths ... because there is only one currentPath list! So you'll end up with allPaths having repeated references to one and the same list.

Concluding: it is important to take a copy of currentPath which will not be mutated any more by the future mutations on currentPath . It is like taking a snapshot of the current state of currentPath .

Answer 2

The find_paths_recursive function was designed such that appending to allPaths is the way to return the results to the caller.

def find_paths(root, required_sum):
  allPaths = []
  find_paths_recursive(root, required_sum, [], allPaths)
  return allPaths

Here in find_paths , allPaths is passed to find_paths_recursive as an empty list and after it is done, it will contain the results (paths from root to leaf which fulfill the described condition).

Answer 3

I would recommend breaking the problem down into separate parts. First we write a generic paths function -

def paths (t = None, p = ()):
  if not t:
    return
  elif t.left or t.right:
    yield from paths(t.left, (*p, t.val))
    yield from paths(t.right, (*p, t.val))
  else:
    yield (*p, t.val)

mytree = TreeNode \
  ( 12
  , TreeNode(7, TreeNode(4))
  , TreeNode(1, TreeNode(10)) 
  )

Now we can see how paths works -

for p in paths(mytree):
  print(p)

(12, 7, 4)
(12, 1, 10)

Now we can write solver that specializes paths -

def solver (t = None, q = 0):
  for p in paths(t):
    if sum(p) == q:
      yield p

solver is a generator which yields all possible solutions. It is a good choice for programs like this because you can pause/cancel the solving as soon as you found the solution(s) you are looking for -

for sln in solver(mytree, 23):
  print(sln)

The output isn't particularly interesting because each branch in mytree sums to 23 -

(12, 7, 4)
(12, 1, 10)

If we make anothertree with different values, we can see more interesting output -

anothertree = TreeNode \
  ( 1
  , TreeNode(7, TreeNode(4), TreeNode(5))
  , TreeNode(9, TreeNode(2), TreeNode(7))
  )

for sln in solver(anothertree, 12):
  print(sln)

(1, 7, 4)
(1, 9, 2)