Two Sum in BST in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two Sum BST check with target 9

What is the output of the following Rust code that checks if there exist two nodes in the BST that sum to 9?

DSA Rust

use std::collections::HashSet;

#[derive(Debug)]
struct TreeNode {
    val: i32,
    left: Option<Box<TreeNode>>,
    right: Option<Box<TreeNode>>,
}

impl TreeNode {
    fn new(val: i32) -> Self {
        TreeNode { val, left: None, right: None }
    }
}

fn find_target(root: &Option<Box<TreeNode>>, k: i32, set: &mut HashSet<i32>) -> bool {
    match root {
        None => false,
        Some(node) => {
            if set.contains(&(k - node.val)) {
                true
            } else {
                set.insert(node.val);
                find_target(&node.left, k, set) || find_target(&node.right, k, set)
            }
        }
    }
}

fn main() {
    let mut root = Box::new(TreeNode::new(5));
    root.left = Some(Box::new(TreeNode::new(3)));
    root.right = Some(Box::new(TreeNode::new(6)));
    root.left.as_mut().unwrap().left = Some(Box::new(TreeNode::new(2)));
    root.left.as_mut().unwrap().right = Some(Box::new(TreeNode::new(4)));
    root.right.as_mut().unwrap().right = Some(Box::new(TreeNode::new(7)));

    let mut set = HashSet::new();
    let result = find_target(&Some(root), 9, &mut set);
    println!("{}", result);
}

A true

B false

C Compilation error

D Runtime panic

💡 Hint

Think about pairs of nodes that add up to 9 in the BST.

The BST contains nodes with values 2,3,4,5,6,7. The pair (2,7) sums to 9, so the function returns true.

🧠 Conceptual

intermediate

Understanding Two Sum in BST approach

Which data structure is most suitable to efficiently check if the complement of a node's value exists while traversing a BST for the Two Sum problem?

A Linked List

B HashSet

C Queue

D Stack

💡 Hint

Think about fast membership checking.

HashSet provides O(1) average time complexity for membership checks, making it ideal to check complements during traversal.

❓ Predict Output

advanced

Output of Two Sum BST check with target 30

What is the output of the following Rust code that checks if there exist two nodes in the BST that sum to 30?

DSA Rust

use std::collections::HashSet;

#[derive(Debug)]
struct TreeNode {
    val: i32,
    left: Option<Box<TreeNode>>,
    right: Option<Box<TreeNode>>,
}

impl TreeNode {
    fn new(val: i32) -> Self {
        TreeNode { val, left: None, right: None }
    }
}

fn find_target(root: &Option<Box<TreeNode>>, k: i32, set: &mut HashSet<i32>) -> bool {
    match root {
        None => false,
        Some(node) => {
            if set.contains(&(k - node.val)) {
                true
            } else {
                set.insert(node.val);
                find_target(&node.left, k, set) || find_target(&node.right, k, set)
            }
        }
    }
}

fn main() {
    let mut root = Box::new(TreeNode::new(10));
    root.left = Some(Box::new(TreeNode::new(5)));
    root.right = Some(Box::new(TreeNode::new(15)));
    root.left.as_mut().unwrap().left = Some(Box::new(TreeNode::new(3)));
    root.left.as_mut().unwrap().right = Some(Box::new(TreeNode::new(7)));
    root.right.as_mut().unwrap().right = Some(Box::new(TreeNode::new(18)));

    let mut set = HashSet::new();
    let result = find_target(&Some(root), 30, &mut set);
    println!("{}", result);
}

A Runtime panic

B Compilation error

C true

D false

💡 Hint

Check if any two nodes sum to 30.

The BST nodes are 3,5,7,10,15,18. No two nodes sum to 30, so output is false.

🔧 Debug

advanced

Identify the error in Two Sum BST function

What error will this Rust code produce when trying to compile?

DSA Rust

use std::collections::HashSet;

struct TreeNode {
    val: i32,
    left: Option<Box<TreeNode>>,
    right: Option<Box<TreeNode>>,
}

fn find_target(root: &Option<Box<TreeNode>>, k: i32, set: &mut HashSet<i32>) -> bool {
    match root {
        None => false,
        Some(node) => {
            if set.contains(&(k - node.val)) {
                true
            } else {
                set.insert(node.val);
                find_target(&node.left, k, set) || find_target(&node.right, k, set)
            }
        }
    }
}

fn main() {
    let root = Some(Box::new(TreeNode { val: 1, left: None, right: None }));
    let mut set = HashSet::new();
    println!("{}", find_target(&root, 2, &mut set));
}

A SyntaxError

B TypeError

C Mismatched types error

D No error, prints true or false

💡 Hint

Look at the argument passed to set.contains.

set.contains expects a reference to i32 (&i32), but k - node.val is an i32 value, causing a mismatched types error.

🚀 Application

expert

Number of pairs summing to target in BST

Given a BST with unique values, how many unique pairs of nodes sum to 10? The BST nodes are: 1, 2, 3, 7, 8, 9.

A 3

B 1

C 4

D 2

💡 Hint

Find all pairs (a,b) where a + b = 10 and a != b.

Pairs are (1,9), (2,8), (3,7). Total 3 pairs.

Practice

1. What is the main goal of the Two Sum in BST problem?

easy

A. Find two nodes in the BST whose values add up to a target sum.

B. Find the maximum value in the BST.

C. Count the total number of nodes in the BST.

D. Check if the BST is balanced.

Solution

1. Step 1: Understand the problem statement

   The problem asks to find two nodes in a Binary Search Tree (BST) such that their values add up to a given target sum.

2. Step 2: Clarify the goal

   We need to check if any pair of nodes exists with values summing to the target, not just find max or count nodes.

3. Final Answer:

   Find two nodes in the BST whose values add up to a target sum. -> Option A

4. Quick Check:

   Two Sum in BST = Find pair with target sum [OK]

Hint: Look for two values that add to target in BST [OK]

Common Mistakes:

• Thinking it asks for max value only
• Confusing with counting nodes
• Assuming BST must be balanced

2. Which Rust code snippet correctly defines a BST node struct for the Two Sum problem?

easy

A. struct TreeNode { val: i32, left: TreeNode, right: TreeNode }

B. struct TreeNode { val: i32, left: Option, right: Option }

C. struct TreeNode { val: i32, left: &TreeNode, right: &TreeNode }

D. struct TreeNode { val: i32, left: Option<TreeNode>, right: Option<TreeNode> }

Solution

1. Step 1: Understand Rust ownership and recursive types

   Rust requires recursive types like BST nodes to use Box or other smart pointers to allocate on heap.

2. Step 2: Check each option

   struct TreeNode { val: i32, left: Option, right: Option } uses Option which is correct. struct TreeNode { val: i32, left: TreeNode, right: TreeNode } and D use direct TreeNode which is invalid recursive type. struct TreeNode { val: i32, left: &TreeNode, right: &TreeNode } uses references without lifetimes, which is incorrect.

3. Final Answer:

   struct TreeNode { val: i32, left: Option, right: Option } -> Option B

4. Quick Check:

   Use Box for recursive BST nodes in Rust [OK]

Hint: Use Option for recursive BST nodes [OK]

Common Mistakes:

• Using direct TreeNode type causing infinite size error
• Using references without lifetimes
• Omitting Option for nullable children

3. Given the following BST and target = 9, what will the Two Sum function return?

      5
     / \
    3   6
   / \   \
  2   4   7

Rust code snippet:

fn find_target(root: &Option, k: i32) -> bool {
    let mut set = std::collections::HashSet::new();
    fn dfs(node: &Option, k: i32, set: &mut std::collections::HashSet<i32>) -> bool {
        if let Some(n) = node {
            if set.contains(&(k - n.val)) {
                return true;
            }
            set.insert(n.val);
            dfs(&n.left, k, set) || dfs(&n.right, k, set)
        } else {
            false
        }
    }
    dfs(root, k, &mut set)
}

medium

A. true

B. false

C. Compilation error

D. Runtime panic

Solution

1. Step 1: Trace DFS with HashSet on BST nodes

   Start at root 5, set is empty. Check if complement 9-5=4 in set? No. Insert 5. Check left child 3: complement 9-3=6, 6 not in set. Insert 3. Check left 2: complement 9-2=7, 7 not in set. Insert 2. Check right 4: complement 9-4=5, 5 is in set, so return true.

2. Step 2: Confirm early return on finding pair

   Since pair (5,4) sums to 9, function returns true immediately.

3. Final Answer:

   true -> Option A

4. Quick Check:

   Pair found (5+4=9) = true [OK]

Hint: Check if complement exists in set during DFS [OK]

Common Mistakes:

• Not inserting current node before checking complement
• Returning false too early
• Ignoring left or right subtree

4. Identify the bug in this Rust function for Two Sum in BST:

fn find_target(root: &Option, k: i32) -> bool {
    let mut set = std::collections::HashSet::new();
    fn dfs(node: &Option, k: i32, set: &mut std::collections::HashSet<i32>) -> bool {
        if let Some(n) = node {
            set.insert(n.val);
            if set.contains(&(k - n.val)) {
                return true;
            }
            dfs(&n.left, k, set) || dfs(&n.right, k, set)
        } else {
            false
        }
    }
    dfs(root, k, &mut set)
}

medium

A. Function does not handle empty tree.

B. Missing return statement in dfs function.

C. HashSet is not imported correctly.

D. Inserting current node value before checking complement causes false positive.

Solution

1. Step 1: Analyze order of operations in DFS

   The code inserts current node value into set before checking if complement exists. This causes the complement check to always find current value itself, leading to false positive.

2. Step 2: Correct approach

   Check if complement exists in set first, then insert current node value to avoid matching node with itself.

3. Final Answer:

   Inserting current node value before checking complement causes false positive. -> Option D

4. Quick Check:

   Check complement before insert to avoid false positive [OK]

Hint: Check complement before inserting current value [OK]

Common Mistakes:

• Inserting before checking complement
• Ignoring early return on true
• Not handling None nodes

5. You want to optimize the Two Sum in BST problem to use O(h) space, where h is tree height. Which approach is best? A BST inorder iterator yields sorted values. How can you use two iterators to solve Two Sum efficiently?

hard

A. Use a HashSet to store visited nodes and check complements during DFS.

B. Traverse BST in preorder and store all values in a vector, then use two pointers on vector.

C. Use two iterators: one from smallest to largest, another from largest to smallest, moving inward to find target sum.

D. Convert BST to linked list and then check pairs sequentially.

Solution

1. Step 1: Understand space constraints and BST properties

   Storing all nodes uses O(n) space. Using BST inorder iterator yields sorted values with O(h) space.

2. Step 2: Use two iterators moving inward

   One iterator moves from smallest to largest (inorder), another from largest to smallest (reverse inorder). Compare sums and move iterators accordingly to find target sum efficiently.

3. Step 3: Compare with other options

   Traverse BST in preorder and store all values in a vector, then use two pointers on vector. uses O(n) space. Use a HashSet to store visited nodes and check complements during DFS. uses HashSet with O(n) space. Convert BST to linked list and then check pairs sequentially. is inefficient and uses extra space.

4. Final Answer:

   Use two iterators: one from smallest to largest, another from largest to smallest, moving inward to find target sum. -> Option C

5. Quick Check:

   Two BST iterators inward = O(h) space Two Sum [OK]

Hint: Use two BST iterators from ends moving inward [OK]

Common Mistakes:

• Using full traversal storing all nodes
• Ignoring space complexity
• Not using reverse inorder iterator