BST Search Operation in DSA Rust - Execution Trace

Concept Flow - BST Search Operation

Start at root node

↓

Compare target with current node

↓

Target < current?

↓

Go left

↓

Node is None?

Yes→Target not found

No↓

Target == current?

Yes→Target found

No↓

Repeat comparison

Start at the root, compare the target with current node's value, go left if smaller, right if larger, repeat until found or no node.

Execution Sample

DSA Rust

fn bst_search(root: &Option<Box<Node>>, target: i32) -> bool {
    let mut current = root.as_ref();
    while let Some(node) = current {
        if target == node.val {
            return true;
        } else if target < node.val {
            current = node.left.as_ref();
        } else {
            current = node.right.as_ref();
        }
    }
    false
}

Searches for a target value in a BST by traversing left or right based on comparisons.

Execution Table

Step	Operation	Current Node Value	Comparison	Pointer Change	Visual State
1	Start at root	10	target=7 < 10	Move to left child	10 / \ 5 15
2	Compare with node 5	5	target=7 > 5	Move to right child	10 / \ 5 15 \ 7
3	Compare with node 7	7	target=7 == 7	Found target	10 / \ 5 15 \ 7
4	Exit	N/A	Target found	Stop	10 / \ 5 15 \ 7

💡 Target 7 found at node with value 7, search ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
current	root (10)	node with value 5	node with value 7	node with value 7	N/A
target	7	7	7	7	7

Key Moments - 3 Insights

Why do we move left when target is less than current node?

Because in a BST, all left children have smaller values than the current node, so the target must be in the left subtree if smaller. See execution_table step 1.

What happens if the current node is None during traversal?

It means we reached a leaf without finding the target, so the target is not in the tree. This stops the search. See execution_table exit note.

Why do we stop when target equals current node value?

Because we found the target value in the tree, so the search is successful and ends. See execution_table step 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the current node value at step 2?

A 10

B 5

C 7

D 15

💡 Hint

Check the 'Current Node Value' column in execution_table row for step 2.

At which step does the search find the target value?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for the step where 'Comparison' shows target == current node.

If the target was 20, which pointer change would happen after step 1?

A Move to left child

B Move to right child

C Found target

D Stop

💡 Hint

Compare target 20 with root 10 in execution_table step 1 logic.

Concept Snapshot

BST Search Operation:
- Start at root node
- Compare target with current node value
- If target < current, go left
- If target > current, go right
- Repeat until found or no node
- Return true if found, false if not

Full Transcript

The BST search operation starts at the root node. At each step, it compares the target value with the current node's value. If the target is smaller, it moves to the left child; if larger, it moves to the right child. This repeats until the target is found or a leaf node is reached without finding the target. The search returns true if the target is found, otherwise false. The execution table shows the step-by-step traversal for target 7 in a BST with root 10, left child 5, and right child 15, finding the target at node 7.

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