BST Search Operation in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of searching for 7 in this BST?

Consider the following Rust code that builds a binary search tree (BST) and searches for the value 7.

struct Node {
    val: i32,
    left: Option>,
    right: Option>,
}

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

    fn insert(&mut self, val: i32) {
        if val < self.val {
            match &mut self.left {
                Some(left_node) => left_node.insert(val),
                None => self.left = Some(Box::new(Node::new(val))),
            }
        } else if val > self.val {
            match &mut self.right {
                Some(right_node) => right_node.insert(val),
                None => self.right = Some(Box::new(Node::new(val))),
            }
        }
    }

    fn search(&self, val: i32) -> bool {
        if val == self.val {
            true
        } else if val < self.val {
            match &self.left {
                Some(left_node) => left_node.search(val),
                None => false,
            }
        } else {
            match &self.right {
                Some(right_node) => right_node.search(val),
                None => false,
            }
        }
    }
}

fn main() {
    let mut root = Node::new(10);
    root.insert(5);
    root.insert(15);
    root.insert(3);
    root.insert(7);
    root.insert(12);
    root.insert(18);

    println!("{}", root.search(7));
}

A false

B true

C Compilation error

D Runtime panic

💡 Hint

Think about whether the value 7 was inserted into the tree before searching.

The value 7 was inserted into the BST, so searching for 7 returns true.

❓ Predict Output

intermediate

What is the output of searching for 6 in this BST?

Using the same BST as before, what will be the output of searching for the value 6?

fn main() {
    let mut root = Node::new(10);
    root.insert(5);
    root.insert(15);
    root.insert(3);
    root.insert(7);
    root.insert(12);
    root.insert(18);

    println!("{}", root.search(6));
}

A false

B Compilation error

C true

D Runtime panic

💡 Hint

Check if 6 was inserted into the tree before searching.

The value 6 was never inserted, so searching returns false.

🔧 Debug

advanced

What error does this Rust BST search code produce?

Consider this Rust code snippet for BST search. What error does it produce when compiled?

fn search(&self, val: i32) -> bool {
    if val == self.val {
        true
    } else if val < self.val {
        if let Some(left_node) = &self.left {
            left_node.search(val)
        } else {
            false
        }
    } else {
        if let Some(right_node) = &self.right {
            right_node.search(val)
        } else {
            false
        }
    }
}

A Missing return in else branch error

B No error, compiles fine

C Type mismatch error

D Borrow checker error

💡 Hint

Check if all branches return a boolean value.

The last else branch does not return a value if right is None, causing a missing return error.

🧠 Conceptual

advanced

How many nodes are visited when searching for 12 in this BST?

Given the BST constructed by inserting 10, 5, 15, 3, 7, 12, 18 in that order, how many nodes are visited during a search for 12?

A 4

B 2

C 5

D 3

💡 Hint

Trace the path from root to the node with value 12.

Nodes visited: 10 (root), 15 (right child), 12 (left child of 15) → total 3 nodes.

🚀 Application

expert

What is the output after searching for 20 in this BST and printing the result?

Consider this Rust code snippet:

fn main() {
    let mut root = Node::new(10);
    root.insert(5);
    root.insert(15);
    root.insert(3);
    root.insert(7);
    root.insert(12);
    root.insert(18);

    let found = root.search(20);
    println!("{}", found);
}

What will be printed?

A true

B Compilation error

C false

D Runtime panic

💡 Hint

Was 20 inserted into the BST before searching?

20 was never inserted, so search returns false.

Practice

1. What does the search operation in a Binary Search Tree (BST) do?

easy

A. Counts the number of nodes in the BST

B. Inserts a new value into the BST

C. Deletes a value from the BST

D. Finds whether a given value exists in the BST

Solution

1. Step 1: Understand the purpose of BST search

   The search operation checks if a specific value is present in the BST by comparing values and moving left or right accordingly.

2. Step 2: Differentiate from other BST operations

   Insertion adds new nodes, deletion removes nodes, and counting nodes is a separate operation. Search only checks presence.

3. Final Answer:

   Finds whether a given value exists in the BST -> Option D

4. Quick Check:

   Search = Find value [OK]

Hint: Search checks presence, not insertion or deletion [OK]

Common Mistakes:

• Confusing search with insert or delete
• Thinking search counts nodes
• Assuming search modifies the tree

2. Which of the following is the correct Rust function signature for a BST search method that returns a boolean?

easy

A. fn search(&mut self, value: i32) -> i32

B. fn search(value: i32) -> bool

C. fn search(&self, value: i32) -> bool

D. fn search(&self, value: i32) -> Option<Node>

Solution

1. Step 1: Identify method receiver and return type

   Search should borrow the tree immutably (&self) and return true/false (bool) indicating presence.

2. Step 2: Check parameters and return correctness

   Value parameter is i32, and return type is bool. Mutable borrow or returning Node is incorrect for simple search.

3. Final Answer:

   fn search(&self, value: i32) -> bool -> Option C

4. Quick Check:

   Immutable borrow + bool return = fn search(&self, value: i32) -> bool [OK]

Hint: Search does not modify tree, so use &self and bool return [OK]

Common Mistakes:

• Using &mut self instead of &self
• Returning Node instead of bool
• Missing self parameter

3. Given this Rust code for BST search, what will be printed when searching for 7?

struct Node {
    value: i32,
    left: Option,
    right: Option,
}

impl Node {
    fn search(&self, val: i32) -> bool {
        if val == self.value {
            true
        } else if val < self.value {
            match &self.left {
                Some(left_node) => left_node.search(val),
                None => false,
            }
        } else {
            match &self.right {
                Some(right_node) => right_node.search(val),
                None => false,
            }
        }
    }
}

fn main() {
    let root = Node {
        value: 5,
        left: Some(Box::new(Node { value: 3, left: None, right: None })),
        right: Some(Box::new(Node { value: 8, left: None, right: None })),
    };
    println!("{}", root.search(7));
}

medium

A. false

B. Runtime panic

C. Compilation error

D. true

Solution

1. Step 1: Trace search for value 7 starting at root 5

   7 > 5, so search right subtree with root 8.

2. Step 2: Search right subtree node with value 8 for 7

   7 < 8, so search left subtree of node 8, which is None, so returns false.

3. Final Answer:

   false -> Option A

4. Quick Check:

   7 not found in tree = false [OK]

Hint: Follow BST rules: left < node < right [OK]

Common Mistakes:

• Assuming 7 is found because 8 exists
• Confusing left and right subtree directions
• Ignoring None case returns false

4. Identify the bug in this Rust BST search method:

fn search(&self, val: i32) -> bool {
    if val == self.value {
        true
    } else if val < self.value {
        self.left.as_ref().unwrap().search(val)
    } else {
        self.right.as_ref().unwrap().search(val)
    }
}

medium

A. Using unwrap() without checking if child exists can cause panic

B. Missing return keyword before recursive calls

C. Incorrect comparison operators used

D. Function should return Option<bool> instead of bool

Solution

1. Step 1: Analyze use of unwrap() on Option

   unwrap() assumes the Option is Some, but if child is None, it causes runtime panic.

2. Step 2: Understand safe alternative

   Should check if child exists using match or if let before calling search to avoid panic.

3. Final Answer:

   Using unwrap() without checking if child exists can cause panic -> Option A

4. Quick Check:

   unwrap() on None = panic [OK]

Hint: Never unwrap Option without checking Some first [OK]

Common Mistakes:

• Ignoring possibility of None causing panic
• Thinking unwrap() is safe always
• Confusing return types

5. You want to search for a value in a BST that may contain duplicate values on the right subtree. How should you modify the search operation to find if the value exists anywhere in the tree?

hard

A. Search left subtree if val <= node, else search right subtree

B. Search left subtree if val < node, else search both right subtree and current node for val

C. Search left subtree if val < node, else search right subtree and if not found, search left subtree again

D. Search both left and right subtrees regardless of comparison, then check current node

Solution

1. Step 1: Understand duplicates on right subtree

   Duplicates are stored on the right, so if val equals node value, we found it; else if val > node, search right subtree.

2. Step 2: Modify search to check current node and right subtree for duplicates

   If val equals node value, return true immediately. If val > node value, search right subtree. If val < node value, search left subtree.

3. Final Answer:

   Search left subtree if val < node, else search both right subtree and current node for val -> Option B

4. Quick Check:

   Duplicates on right: check current and right subtree [OK]

Hint: Check current node before right subtree for duplicates [OK]

Common Mistakes:

• Ignoring duplicates on right subtree
• Searching only one subtree without checking current node
• Searching left subtree unnecessarily for duplicates