Two Sum IV - Input is a BST - Practice Coding Problems

Two Sum IV - Input is a BST - Problem

Given the root of a binary search tree and an integer k, return true if there exist two distinct elements in the BST such that their sum equals k, or false otherwise.

This problem leverages the unique properties of Binary Search Trees where elements are organized in a sorted manner. The challenge is to efficiently find two nodes whose values sum to the target value k.

Note: You cannot use the same element twice, and the two elements must be different nodes in the tree.

Input & Output

example_1.py — Basic BST

$ Input: root = [5,3,6,2,4,null,7], k = 9

› Output: true

💡 Note: We can find two nodes with values 2 and 7 that sum to 9 (2 + 7 = 9). These are distinct nodes in the BST.

example_2.py — No Valid Pair

$ Input: root = [5,3,6,2,4,null,7], k = 28

› Output: false

💡 Note: No two distinct nodes in the BST have values that sum to 28. The maximum possible sum is 6 + 7 = 13.

example_3.py — Single Node

$ Input: root = [2], k = 4

› Output: false

💡 Note: The BST contains only one node with value 2. We need two distinct nodes, so it's impossible to find a pair that sums to 4.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁴ ≤ Node.val ≤ 10⁴
-10⁵ ≤ k ≤ 10⁵
The tree is guaranteed to be a valid binary search tree

Visualization

Tap to expand

Understanding the Visualization

Start with empty memory

Begin traversal with empty hash set to remember values

Check each node

For node with value v, check if (k-v) was seen before

Remember current value

Add current node's value to hash set for future lookups

Continue until found

Repeat process until pair found or tree fully traversed

Key Takeaway

🎯 Key Insight: Hash sets provide O(1) complement lookup, making single-pass traversal optimal for this two-sum variant on tree structures!

Asked in

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

The optimal approach uses a hash set during a single tree traversal. For each node, check if its complement (k - node.val) exists in the set. This achieves O(n) time and works for any binary tree, though the two-pointers approach after inorder traversal specifically leverages BST properties for an elegant sorted-array solution.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (BST Inorder)	O(n)	O(n)	Convert BST to sorted array via inorder traversal, then use two pointers
Brute Force (Nested Tree Traversal)	O(n²)	O(h)	For each node, traverse the entire tree to find its complement
Hash Set (Optimal for Generic Trees)	O(n)	O(n)	Traverse tree once, checking complements in hash set during traversal

Two Pointers (BST Inorder) — Algorithm Steps

Perform inorder traversal to get sorted array of values
Initialize left pointer at start, right pointer at end
Calculate sum of values at both pointers
If sum equals k, return true
If sum is less than k, move left pointer right
If sum is greater than k, move right pointer left
Continue until pointers meet
Return false if no pair found

Visualization

Tap to expand

Step-by-Step Walkthrough

Inorder traversal

Extract values in sorted order: [2,3,4,5,6,7]

Initialize pointers

Left at index 0, right at last index

Check sum

If sum < k, move left right; if sum > k, move right left

Found or exhausted

Return true when sum equals k, false when pointers meet

Code -

solution.c — C

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

#define MAX_NODES 10000

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

int values[MAX_NODES];
int values_count = 0;

void inorder(struct TreeNode* node) {
    if (!node) return;
    inorder(node->left);
    values[values_count++] = node->val;
    inorder(node->right);
}

bool findTarget(struct TreeNode* root, int k) {
    values_count = 0;
    inorder(root);
    
    int left = 0, right = values_count - 1;
    while (left < right) {
        int currentSum = values[left] + values[right];
        if (currentSum == k) {
            return true;
        } else if (currentSum < k) {
            left++;
        } else {
            right--;
        }
    }
    
    return false;
}

int main() {
    int k;
    scanf("%d", &k);
    printf("%s\n", findTarget(NULL, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for inorder traversal + O(n) for two-pointer search

✓ Linear Growth

Space Complexity

O(n)

Array to store n values + O(h) recursion stack for inorder

⚡ Linearithmic Space

52.0K Views

High Frequency

~15 min Avg. Time

1.9K 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 (BST Inorder) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler