# Calculating Sum of Diagonal Path Elements in a Binary Tree Using Python

Rate this post

π‘ Problem Formulation: This article serves to educate on computing the sum of elements along each diagonal path in a binary tree through various methods in Python. A binary tree’s diagonal paths are lines of nodes that extend from the root node to the rightmost parts of the binary tree traversing down at an angle. The input is a binary tree and the output is a list of sums, each representing the total value of the diagonal path from the top to the bottom.

## Method 1: Recursive Summation with Hashmap

This method involves performing a depth-first search traversal of the binary tree and using a recursive function to maintain a hashmap to keep track of the sums of each diagonal. The hashmap uses the diagonal number as the key and its sum as the value.

Here’s an example:

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

def diagonalSum(root):
diagonal_sums = {}
def _diagonalSumHelper(node, diagonal, sums_dict):
if not node: return
sums_dict.setdefault(diagonal, 0)
sums_dict[diagonal] += node.val
_diagonalSumHelper(node.left, diagonal + 1, sums_dict)
_diagonalSumHelper(node.right, diagonal, sums_dict)
_diagonalSumHelper(root, 0, diagonal_sums)
return [diagonal_sums[x] for x in sorted(diagonal_sums)]

# Example Tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(9)
root.right.left = TreeNode(6)
root.right.right = TreeNode(4)
root.left.left.right = TreeNode(10)
root.right.left.left = TreeNode(11)

print(diagonalSum(root))```

The output for this code snippet:

• [1, 3, 12, 10]

This method recurses through the tree, depths-first, using a helper function to calculate and store the sums at each diagonal level in a dictionary. If a left child exists, it traverses to the next diagonal (diagonal + 1), and for a right child, it stays on the same diagonal. We then construct the resulting list of sums by iterating through the sorted keys of the dictionary.

## Method 2: Iterative with Queue and Hashmap

Diagonal sums can also be computed iteratively using a queue. Each node is processed level by level, and the diagonal level information is preserved through the use of a tuple that contains the node and its diagonal level. A hashmap is used to keep track of the sums.

Here’s an example:

```from collections import deque

def diagonalSumIterative(root):
if not root:
return []

diagonal_sums = {}
queue = deque([(root, 0)])

while queue:
node, diagonal = queue.popleft()
diagonal_sums.setdefault(diagonal, 0)
diagonal_sums[diagonal] += node.val

if node.left:
queue.append((node.left, diagonal+1))
if node.right:
queue.append((node.right, diagonal))

return [diagonal_sums[x] for x in sorted(diagonal_sums.keys())]

print(diagonalSumIterative(root))```

The output for this code snippet:

• [1, 3, 12, 10]

In this approach, we traverse the tree level by level and employ a queue to track nodes along with their diagonal number. The queue helps us to iteratively process the nodes while maintaining the diagonal property, and a hashmap collects the sums.

## Method 3: Space-Optimized Recursive Method

The space-optimized recursive method focuses on reducing hashmap size by keeping track of maximum diagonal number reached and appending the sum directly into a list at the indexed position corresponding to the diagonal number.

Here’s an example:

```def diagonalSumSpaceOptimized(root):
sums_list = []
def _helper(node, diagonal, sums_list):
if not node:
return
if diagonal >= len(sums_list):
sums_list.append(0)
sums_list[diagonal] += node.val
_helper(node.left, diagonal + 1, sums_list)
_helper(node.right, diagonal, sums_list)
_helper(root, 0, sums_list)
return sums_list

print(diagonalSumSpaceOptimized(root))```

The output for this code snippet:

• [1, 3, 12, 10]

In this methodology, a list is directly manipulated to hold sums. The recursive function checks if the current diagonal level exceeds the list length and appends an initial sum if required, ensuring that each diagonal has a unique index in our list.

## Method 4: Diagonal Traversal with Depth Calculation

This technique involves performing a diagonal traversal and explicitly calculating the depth to determine the diagonal number. The depth calculation accounts for the vertical displacement within the binary tree structure.

Here’s an example:

```def diagonalSumDepth(root):
sums_list = []
def _diagonalTraversal(node, depth, sums_list):
if node is None:
return
if depth == len(sums_list):
sums_list.append(0)
sums_list[depth] += node.val
_diagonalTraversal(node.right, depth, sums_list)
_diagonalTraversal(node.left, depth + 1, sums_list)
_diagonalTraversal(root, 0, sums_list)
return sums_list

print(diagonalSumDepth(root))```

The output for this code snippet:

• [1, 3, 12, 10]

This variant modifies the space-optimized recursive method by adjusting the function to process the right child first and then the left child, ensuring that the depth is calculated considering a diagonal traversal.

## Bonus One-Liner Method 5: Functional Approach with Global Variable

For enthusiasts of functional programming in Python, this method cleverly uses a global variable with higher-order functions like map and reduce for a neat one-liner solution.

Here’s an example:

```diagonal_sums = {}
list(map(lambda d: diagonal_sums.setdefault(d, 0), [0]))
print(diagonal_sum)```

The output for this theoretical example would require a binary tree structure and an appropriate lambda function to be meaningful.

This approach is not a practical method for computing diagonal sums in a binary tree, but simply a representation of the capabilities of Python’s functional programming tools.

## Summary/Discussion

• Method 1: Recursive Summation with Hashmap. Strengths: Clear and logical recursion, easy to understand. Weaknesses: Recursive calls can be heavy on the stack for deep trees.
• Method 2: Iterative with Queue and Hashmap. Strengths: Iterative approach is stack-efficient, breadth-first method provides insight into the tree structure. Weaknesses: Slightly more complex logic and requires additional space for the queue.
• Method 3: Space-Optimized Recursive Method. Strengths: Space efficient with direct list indexing, minimizes auxiliary space usage. Weaknesses: Recursion might still be a concern for very deep trees.
• Method 4: Diagonal Traversal with Depth Calculation. Strengths: Depth calculation offers a more implicit way to handle diagonal indexing, this method is conceptually intuitive. Weaknesses: Depends heavily on the correctness of the depth calculation which can be error-prone.
• Method 5: Functional Approach with Global Variable. Strengths: Showcases Python’s functional programming abilities. Weaknesses: Not a fully fleshed-out method, less practical and more conceptual.