Two Sum BSTs

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

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

✓ Brute Force (All Pairs)

⏱️ Time: O(m × n) Space: O(h1 + h2)

The simplest approach is to traverse every node in the first BST, and for each node, traverse every node in the second BST to check if their sum equals the target. This requires nested traversals of both trees.

Two Pointers (Optimal)

⏱️ Time: O(m + n) Space: O(m + n + h1 + h2)

Leverage the BST property by performing in-order traversal to get sorted arrays from both BSTs. Then use two pointers technique - one starting from the beginning of first array, another from the end of second array, moving them based on the current sum compared to target.

Two-Pass Hash Table

⏱️ Time: O(m + n) Space: O(m + h1 + h2)

First, traverse the entire first BST and store all values in a hash set. Then traverse the second BST, and for each node check if the complement (target - current_value) exists in the hash set.

Brute Force (All Pairs) — Algorithm Steps

Traverse each node in the first BST
For each node in first BST, traverse each node in second BST
Check if the sum of current nodes equals target
Return true immediately if target sum is found
Return false if no valid pair is found after checking all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with root of first BST

Begin traversal from root1, checking against all nodes in BST2

Check all nodes in second BST

For current node in BST1, traverse entire BST2 looking for complement

Move to next node in first BST

Continue with next node in BST1 and repeat the process

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

static int arr1[10000], arr2[10000];
static bool isNull1[10000], isNull2[10000];
static struct TreeNode* queue[10000];
static int queueFront, queueRear;

struct TreeNode* newNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = node->right = NULL;
    return node;
}

void queuePush(struct TreeNode* node) {
    queue[queueRear++] = node;
}

struct TreeNode* queuePop() {
    return queue[queueFront++];
}

bool queueEmpty() {
    return queueFront >= queueRear;
}

struct TreeNode* buildTreeFromArray(int* arr, bool* isNull, int size) {
    if (size == 0 || isNull[0]) {
        return NULL;
    }
    
    struct TreeNode* root = newNode(arr[0]);
    queueFront = queueRear = 0;
    queuePush(root);
    int i = 1;
    
    while (!queueEmpty() && i < size) {
        struct TreeNode* node = queuePop();
        
        if (i < size && !isNull[i]) {
            node->left = newNode(arr[i]);
            queuePush(node->left);
        }
        i++;
        
        if (i < size && !isNull[i]) {
            node->right = newNode(arr[i]);
            queuePush(node->right);
        }
        i++;
    }
    
    return root;
}

void parseTreeInput(char* line, int* arr, bool* isNull, int* size) {
    *size = 0;
    char* token = strtok(line, ",");
    
    while (token != NULL) {
        // Trim whitespace
        while (*token == ' ' || *token == '\t') token++;
        char* end = token + strlen(token) - 1;
        while (end > token && (*end == ' ' || *end == '\t')) end--;
        *(end + 1) = '\0';
        
        if (strlen(token) == 0 || strcmp(token, "null") == 0) {
            arr[*size] = 0;
            isNull[*size] = true;
        } else {
            arr[*size] = atoi(token);
            isNull[*size] = false;
        }
        (*size)++;
        token = strtok(NULL, ",");
    }
}

bool searchInBST(struct TreeNode* node, int val) {
    if (!node) {
        return false;
    }
    if (node->val == val) {
        return true;
    } else if (val < node->val) {
        return searchInBST(node->left, val);
    } else {
        return searchInBST(node->right, val);
    }
}

bool hasTarget(struct TreeNode* node1, struct TreeNode* node2, int target) {
    if (!node1) {
        return false;
    }
    
    if (searchInBST(node2, target - node1->val)) {
        return true;
    }
    
    return hasTarget(node1->left, node2, target) || hasTarget(node1->right, node2, target);
}

bool twoSumBSTs(struct TreeNode* root1, struct TreeNode* root2, int target) {
    return hasTarget(root1, root2, target);
}

int main() {
    char root1Input[10000], root2Input[10000];
    int target;
    
    fgets(root1Input, sizeof(root1Input), stdin);
    fgets(root2Input, sizeof(root2Input), stdin);
    scanf("%d", &target);
    
    // Remove newlines
    root1Input[strcspn(root1Input, "\n")] = 0;
    root2Input[strcspn(root2Input, "\n")] = 0;
    
    int size1, size2;
    parseTreeInput(root1Input, arr1, isNull1, &size1);
    parseTreeInput(root2Input, arr2, isNull2, &size2);
    
    struct TreeNode* root1 = buildTreeFromArray(arr1, isNull1, size1);
    struct TreeNode* root2 = buildTreeFromArray(arr2, isNull2, size2);
    
    bool result = twoSumBSTs(root1, root2, target);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each of the m nodes in first BST, and for each visit all n nodes in second BST

✓ Linear Growth

Space Complexity

O(h1 + h2)

Space for recursion stack depth, where h1 and h2 are heights of the two BSTs

✓ Linear 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

Brute Force (All Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler