Two Sum in BST in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert a value into the BST.

DSA Rust

fn insert(root: &mut Option<Box<TreeNode>>, val: i32) {
    match root {
        None => *root = Some(Box::new(TreeNode { val, left: None, right: None })),
        Some(node) => {
            if val < node.val {
                insert(&mut node.left, [1]);
            } else {
                insert(&mut node.right, val);
            }
        }
    }
}

Drag options to blanks, or click blank then click option'

Aval

Bval + 1

Cnode.val

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Passing node.val instead of val causes incorrect insertion.

Modifying val before passing leads to wrong tree structure.

We need to insert the exact value 'val' into the left subtree if it is less than the current node's value.

2fill in blank

medium

Complete the code to perform in-order traversal and collect node values.

DSA Rust

fn inorder(root: &Option<Box<TreeNode>>, vals: &mut Vec<i32>) {
    if let Some(node) = root {
        inorder(&node.left, vals);
        vals.push([1]);
        inorder(&node.right, vals);
    }
}

Drag options to blanks, or click blank then click option'

Aroot.unwrap().val

Bvals.len() as i32

Cnode.left.val

Dnode.val

Attempts:

3 left

💡 Hint

Common Mistakes

Using node.left.val causes error if left is None.

Using vals.len() is unrelated to node values.

We push the current node's value during in-order traversal.

3fill in blank

hard

Fix the error in the two_sum function to check if the complement exists.

DSA Rust

fn two_sum(vals: &Vec<i32>, target: i32) -> bool {
    let mut left = 0;
    let mut right = vals.len() - 1;
    while left < right {
        let sum = vals[left] + vals[right];
        if sum == target {
            return true;
        } else if sum < target {
            left += [1];
        } else {
            right -= 1;
        }
    }
    false
}

Drag options to blanks, or click blank then click option'

A0

B1

Cleft

Dright

Attempts:

3 left

💡 Hint

Common Mistakes

Incrementing by 0 causes infinite loop.

Using left or right as increment value causes type errors.

We need to increment left by 1 to move forward when sum is less than target.

4fill in blank

hard

Fill both blanks to create a function that returns true if two numbers sum to target in BST.

DSA Rust

fn find_target(root: &Option<Box<TreeNode>>, target: i32) -> bool {
    let mut vals = Vec::new();
    [1](&root, &mut vals);
    [2](&vals, target)
}

Drag options to blanks, or click blank then click option'

Ainorder

Btwo_sum

Cinsert

Dsearch

Attempts:

3 left

💡 Hint

Common Mistakes

Calling insert or search instead of inorder or two_sum.

Mixing order of function calls.

We first collect values with inorder traversal, then check pairs with two_sum.

5fill in blank

hard

Fill all three blanks to complete the TreeNode struct and implement find_target.

DSA Rust

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

fn find_target(root: &Option<Box<TreeNode>>, target: i32) -> bool {
    let mut vals = Vec::new();
    [3](&root, &mut vals);
    two_sum(&vals, target)
}

Drag options to blanks, or click blank then click option'

Aleft

Bright

Cinorder

Dval

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'val' as a child field name.

Calling wrong function instead of inorder.

TreeNode has left and right children; inorder collects values for two_sum.

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