Program to find out the largest sum value of a BST in a given binary tree in Python

Suppose we are provided a binary tree. We have to find out if there exist binary search trees (BST) in the subtrees of it and find out the sum of the largest BST. To find out the sum, we add the values of each node in that BST. We return the sum value as output.

So, if the input is like ?

then the output will be 12.

The BST in the given binary tree is ?

sum of the nodes = 12.

Algorithm

To solve this, we will follow these steps ?

• c := 0 (to track the maximum BST size)
• m := null (to store the root of largest BST)
• value := 0 (to store the sum)
• Define a function recurse() that takes a node:
  • if node is not null, then
    • left_val := recurse(left of node)
    • right_val := recurse(right of node)
    • count := negative infinity
    • if (node.left is null or node.left.val <= node.val) and (node.right is null or node.val <= node.right.val), then
      • count := left_val + right_val + 1
    • if count > c, then
      • c := count
      • m := node
    • return count
  • return 0
• Define a function calculate_sum() that takes root:
  • if root is not null, then
    • calculate_sum(left of root)
    • value := value + value of root
    • calculate_sum(right of root)
• recurse(root)
• calculate_sum(m)
• return value

Example

Let us see the following implementation to get better understanding ?

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

def insert(temp, data):
    que = []
    que.append(temp)
    while (len(que)):
        temp = que[0]
        que.pop(0)
        if (not temp.left):
            if data is not None:
                temp.left = TreeNode(data)
            else:
                temp.left = TreeNode(0)
            break
        else:
            que.append(temp.left)
        if (not temp.right):
            if data is not None:
                temp.right = TreeNode(data)
            else:
                temp.right = TreeNode(0)
            break
        else:
            que.append(temp.right)

def make_tree(elements):
    tree = TreeNode(elements[0])
    for element in elements[1:]:
        insert(tree, element)
    return tree

def solve(root):
    c, m, value = 0, None, 0
    
    def recurse(node):
        if node:
            nonlocal c, m
            left_val = recurse(node.left)
            right_val = recurse(node.right)
            count = -float("inf")
            
            # Check if current node forms a valid BST
            if (node.left == None or node.left.val <= node.val) and (node.right == None or node.val <= node.right.val):
                count = left_val + right_val + 1
            
            # Update largest BST if current BST is larger
            if count > c:
                c = count
                m = node
            return count
        return 0
    
    def calculate_sum(root):
        nonlocal value
        if root is not None:
            calculate_sum(root.left)
            value += root.val
            calculate_sum(root.right)
    
    recurse(root)
    calculate_sum(m)
    return value

# Create the tree and find largest BST sum
tree = make_tree([1, 4, 6, 3, 5])
result = solve(tree)
print(f"Sum of largest BST: {result}")

The output of the above code is ?

Sum of largest BST: 12

How It Works

The algorithm works in two phases:

• Phase 1: The recurse() function traverses the tree and identifies the largest valid BST by counting nodes. It checks BST property by ensuring left child ? parent ? right child.
• Phase 2: The calculate_sum() function performs an in-order traversal of the identified largest BST and calculates the sum of all its nodes.

The BST validation checks if the left child's value is less than or equal to the current node's value, and the current node's value is less than or equal to the right child's value.

Conclusion

This approach efficiently finds the largest BST within a binary tree by first identifying the BST with maximum nodes, then calculating its sum. The algorithm uses recursive traversal to validate BST properties and maintains global variables to track the largest valid BST found.