Two Sum BSTs - Practice Coding Problems

Two Sum BSTs - Problem

You are given the roots of two binary search trees, root1 and root2. Your task is to determine if there exists a pair of nodes - one from each tree - whose values sum up to a given target integer.

Return true if such a pair exists, otherwise return false.

Example: If the first BST contains values [2, 1, 4] and the second BST contains values [1, 0, 3], and the target is 5, then we can find nodes with values 2 (from first tree) and 3 (from second tree) that sum to 5.

This problem leverages the sorted property of BSTs to find efficient solutions beyond the naive approach of checking all possible pairs.

Input & Output

example_1.py — Basic Case

$ Input: root1 = [2,1,4], root2 = [1,0,3], target = 5

› Output: true

💡 Note: 2 and 3 sum up to 5. Node with value 2 is from first tree, node with value 3 is from second tree.

example_2.py — No Valid Pair

$ Input: root1 = [0,-10,10], root2 = [5,1,7,0,2], target = 18

› Output: false

💡 Note: No pair of nodes from the two trees sum up to 18. The maximum possible sum would be 10 + 7 = 17.

example_3.py — Single Node Trees

$ Input: root1 = [1], root2 = [2], target = 3

› Output: true

💡 Note: The only nodes from each tree are 1 and 2, which sum to exactly 3.

Constraints

The number of nodes in each tree is in the range [1, 5000]
-10³ ≤ Node.val ≤ 10³
-10⁴ ≤ target ≤ 10⁴
Both input trees are valid binary search trees

Visualization

Tap to expand

Understanding the Visualization

Two Organized Library Sections

Each BST represents a library section with books sorted by ID numbers

Brute Force: Check Every Pair

Walk through every book in section 1, checking it against every book in section 2

Hash Table: Create Index First

Make a quick-lookup index of all IDs in section 1, then check section 2 for complements

Two Pointers: Smart Scanning

Line up books from both sections in order, use two librarians scanning from opposite ends

Key Takeaway

🎯 Key Insight: Converting BSTs to sorted arrays unlocks the powerful two-pointers technique, giving us optimal O(m + n) performance while maintaining clear, intuitive logic.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses the two-pointers technique after converting both BSTs to sorted arrays via in-order traversal. This leverages the BST property to achieve O(m + n) time complexity with clean, intuitive logic. The hash table approach is also efficient but uses more space, while the brute force method should be avoided due to its O(m × n) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(m + n)	O(m + n + h1 + h2)	Convert BSTs to sorted arrays, then use two pointers from opposite ends
Brute Force (All Pairs)	O(m × n)	O(h1 + h2)	Check every node in first BST against every node in second BST
Two-Pass Hash Table	O(m + n)	O(m + h1 + h2)	Store all values from first BST in hash set, then check complements while traversing second BST

Two Pointers (Optimal) — Algorithm Steps

Perform in-order traversal of first BST to get sorted array
Perform in-order traversal of second BST to get sorted array
Initialize left pointer at start of first array, right pointer at end of second array
Calculate sum of elements at both pointers
If sum equals target, return true
If sum is less than target, move left pointer right
If sum is greater than target, move right pointer left
Return false if pointers cross without finding target

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert BSTs to sorted arrays

Perform in-order traversal to get sorted sequences

Initialize two pointers

Left pointer at start of arr1, right pointer at end of arr2

Move pointers based on sum

Adjust pointers until target sum is found or search space is exhausted

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_NODES 1000
static int arr1[MAX_NODES], arr2[MAX_NODES];
static int size1 = 0, size2 = 0;

void inorder1(struct TreeNode* node) {
    if (!node || size1 >= MAX_NODES) return;
    inorder1(node->left);
    arr1[size1++] = node->val;
    inorder1(node->right);
}

void inorder2(struct TreeNode* node) {
    if (!node || size2 >= MAX_NODES) return;
    inorder2(node->left);
    arr2[size2++] = node->val;
    inorder2(node->right);
}

bool twoSumBSTs(struct TreeNode* root1, struct TreeNode* root2, int target) {
    size1 = size2 = 0;
    
    inorder1(root1);
    inorder2(root2);
    
    int left = 0, right = size2 - 1;
    
    while (left < size1 && right >= 0) {
        int currentSum = arr1[left] + arr2[right];
        
        if (currentSum == target) {
            return true;
        } else if (currentSum < target) {
            left++;
        } else {
            right--;
        }
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + n)

In-order traversal of both BSTs takes O(m + n), two-pointer search also takes O(m + n)

✓ Linear Growth

Space Complexity

O(m + n + h1 + h2)

Arrays to store sorted values from both BSTs plus recursion stack space

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler