BST Search Operation in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to compare the target value with the current node's value.

DSA Rust

if target [1] node.value { return true; }

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

A<

B==

C>

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' or '>' instead of '==' causes wrong comparisons.

Using '!=' will check for inequality, which is incorrect here.

We check if the target is equal to the current node's value to find the element.

2fill in blank

medium

Complete the code to decide to search in the left subtree when target is less than current node's value.

DSA Rust

if target [1] node.value { return search(&node.left, target); }

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

A<

B>

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' will search the wrong subtree.

Using '==' or '!=' here is incorrect for subtree direction.

If the target is less than the current node's value, we search the left subtree.

3fill in blank

hard

Fix the error in the recursive call to search the right subtree when target is greater than current node's value.

DSA Rust

if target [1] node.value { return search(&node.right, target); }

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

A>

B<

C!=

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' will search the wrong subtree.

Using '==' or '!=' here is incorrect for subtree direction.

If the target is greater than the current node's value, we search the right subtree.

4fill in blank

hard

Fill both blanks to complete the recursive BST search function signature and base case check.

DSA Rust

fn search(node: &Option<Box<Node>>, target: i32) -> bool {
    if node.is_[1]() { return [2]; }
    let node = node.as_ref().unwrap();

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

Anone

Bempty

Ctrue

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'is_empty()' which is not a method on Option.

Returning true when node is None causes wrong results.

We check if the node is None (empty), then return false because target is not found.

5fill in blank

hard

Fill all three blanks to complete the recursive BST search function body.

DSA Rust

fn search(node: &Option<Box<Node>>, target: i32) -> bool {
    if node.is_[1]() { return [2]; }
    let node = node.as_ref().unwrap();
    if target [3] node.value { return true; }
    else if target < node.value { return search(&node.left, target); }
    else { return search(&node.right, target); }
}

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

Anone

Bfalse

C==

Dtrue

Attempts:

3 left

💡 Hint

Common Mistakes

Returning true when node is None.

Using wrong comparison operator instead of '=='.

We check if node is None, return false; if target equals node value, return true.

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