# 5 Best Ways to Program to Find Sum of All Numbers Formed by Paths of a Binary Tree in Python

Rate this post

π‘ Problem Formulation: In the context of binary trees, a common challenge is to calculate the sum of all the numbers represented by root-to-leaf paths. Given a binary tree where each node contains a single digit, the goal is to sum all numbers formed by digits from the root to leaves. For instance, the binary tree with root 1, and children 2 and 3, would yield numbers 12 and 13, summing up to 25.

## Method 1: Depth-First Search (DFS) Recursive Approach

This approach uses a depth-first search along with a recursive function to traverse the tree. At each node, the partial number is formed by appending the node’s value, which is propagated down the tree until leaf nodes are reached. At a leaf, the complete number is added to a total sum which is returned after the entire tree is traversed.

Here’s an example:

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

def sumNumbers(root):
def dfs(node, current_number):
if not node:
return 0
current_number = current_number * 10 + node.val
if not node.left and not node.right:
return current_number
return dfs(node.left, current_number) + dfs(node.right, current_number)

return dfs(root, 0)

# Assuming the binary tree is [1,2,3]
n1 = TreeNode(1)
n2 = TreeNode(2)
n3 = TreeNode(3)
n1.left = n2
n1.right = n3

print(sumNumbers(n1))
```

Output: `25`

The code defines a class `TreeNode` representing each node in the binary tree. The function `sumNumbers` uses a helper function `dfs()` to perform a depth-first search where a “current_number” keeps track of the number being built as the tree is traversed. If a leaf node is reached, the current number is added to the sum. The main function starts this process by calling `dfs(root, 0)` and returns the total sum.

## Method 2: Iterative DFS Using Stack

An iterative approach to the DFS algorithm can be used to find the sum of numbers formed by binary tree paths. This method applies a stack to simulate the recursive calls from the previous method, maintaining consistency in the traversal pattern. Tuple pairs with the node and the value formed up to that node are pushed onto and popped from the stack.

Here’s an example:

```def sumNumbers(root):
if not root:
return 0
total_sum, stack = 0, [(root, root.val)]
while stack:
node, current_number = stack.pop()
if not node.left and not node.right:
total_sum += current_number
if node.right:
stack.append((node.right, current_number*10 + node.right.val))
if node.left:
stack.append((node.left, current_number*10 + node.left.val))

print(sumNumbers(n1))
```

Output: `25`

Instead of recursion, this code uses a stack to keep track of nodes to visit. Each element in the stack is a tuple containing a node and the number formed up to that node. This method avoids the overhead of recursive calls while following a similar depth-first traversal as used in Method 1.

## Method 3: Breadth-First Search (BFS) with Queue

Breadth-first search can also be used to solve this problem. Unlike DFS, BFS uses a queue to store tuples of nodes along with the numbers formed by traversing the tree level by level. This results in the processing of nodes in a different order but still achieves the same end goal of summing all path numbers.

Here’s an example:

```from collections import deque

def sumNumbers(root):
if not root:
return 0
total_sum, queue = 0, deque([(root, root.val)])
while queue:
node, current_number = queue.popleft()
if not node.left and not node.right:
total_sum += current_number
if node.left:
queue.append((node.left, current_number*10 + node.left.val))
if node.right:
queue.append((node.right, current_number*10 + node.right.val))

print(sumNumbers(n1))
```

Output: `25`

This code employs the `deque` object from the `collections` module to serve as the queue. Node processing follows the left-to-right, top-to-bottom pattern characteristic of BFS. Each number’s formation and the ultimate summation are managed similarly as in the previous methods.

## Method 4: Morris Traversal Technique

Morris Traversal is a tree traversal algorithm that does not require extra space for a stack or queue. Instead, it makes use of leaf nodes’ right pointers to create a temporary link back to the ancestors. However, Morris Traversal is typically described for in-order traversal, and making it work for root-to-leaf path summation would demand thorough modification and is generally more complicated than other methods mentioned here. Therefore, we will omit the exact code for this method and acknowledge its complexity for this specific problem.

## Bonus One-Liner Method 5: Recursive One-Liner

This method harnesses the power and succinctness of Python to perform the DFS approach in a single line of code inside the function body. It is a recursive solution that is both elegant and efficient, though it may sacrifice some readability.

Here’s an example:

```def sumNumbers(root, current_number=0):
return sumNumbers(root.left, current_number*10 + root.val) + sumNumbers(root.right, current_number*10 + root.val) if root else 0

print(sumNumbers(n1))
```

Output: `25`

Using a conditional expression, this one-liner checks if the `root` is not null and recursively calls itself on the left and right children with the updated “current_number”. If `root` is null, it returns 0. This method elegantly captures the essence of root-to-leaf traversal but may be perplexing for those unfamiliar with Python’s syntactic sugar.

## Summary/Discussion

• Method 1: DFS Recursive Approach. Strengths: Intuitive and easy to understand. Weaknesses: Possibility of a stack overflow with deeply nested trees.
• Method 2: Iterative DFS Using Stack. Strengths: Eliminates the risk of stack overflow. Weaknesses: Code complexity is higher than the recursive version.
• Method 3: BFS with Queue. Strengths: Can be more efficient in certain scenarios particularly with unbalanced trees. Weaknesses: Requires more memory per node than DFS.
• Method 4: Morris Traversal Technique. Strengths: Space-efficient as it requires no additional memory for traversal. Weaknesses: Complex and non-intuitive, making it less practical for the given problem.
• Method 5: Recursive One-Liner. Strengths: Elegant and concise. Weaknesses: Potentially unclear and still recursively depth-limited.