Why BST Over Plain Binary Tree in DSA Rust - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to insert a value into a Binary Search Tree (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'

A0

Bval

Cnode.val

Dval + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Passing node.val instead of val causes wrong insertion.

Modifying val before passing leads to incorrect tree structure.

We insert the same value 'val' recursively into the left or right subtree depending on comparison.

2fill in blank

medium

Complete the code to search for a value in a BST.

DSA Rust

fn search(root: &Option<Box<TreeNode>>, val: i32) -> bool {
    match root {
        None => false,
        Some(node) => {
            if val == node.val {
                true
            } else if val [1] node.val {
                search(&node.left, val)
            } else {
                search(&node.right, val)
            }
        }
    }
}

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

A==

B>

C!=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' reverses search direction.

Using '==' in the else-if causes logic errors.

If val is less than node.val, search left subtree; else search right subtree.

3fill in blank

hard

Fix the error in the BST insertion code to maintain BST property.

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 [1] node.val {
                insert(&mut node.right, val);
            } else {
                insert(&mut node.left, val);
            }
        }
    }
}

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

A==

B<

C>

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping left and right insertion breaks BST property.

Using equality in comparison causes incorrect placement.

For BST insertion, values less than node.val go to left subtree.

4fill in blank

hard

Complete the inorder traversal code. In a BST, inorder visits nodes in sorted order (unlike plain binary tree).

DSA Rust

fn inorder(root: &Option<Box<TreeNode>>, result: &mut Vec<i32>) {
    match root {
        None => (),
        Some(node) => {
            inorder(&node.[1], result);
            result.push(node.val);
            inorder(&node.[2], result);
        }
    }
}

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

Aleft

Bright

Cval

Dparent

Attempts:

3 left

💡 Hint

Common Mistakes

Preorder (root-left-right) doesn't sort.

Postorder (left-right-root) doesn't sort.

Inorder: left-root-right gives ascending order in BST due to ordering property.

5fill in blank

hard

Fill in the average time complexities for search to see why BST > plain binary tree.

DSA Rust

/*
Average search time complexity in BST: [1]
Average search time complexity in plain binary tree: [2]
*/

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

AO(n)

BO(log n)

CO(1)

DO(n^2)

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting BST assumes balance/average case.

Assuming plain tree benefits from height alone.

BST: O(log n) average due to sorted order enabling binary search. Plain binary tree: O(n) as no ordering.

Practice

1. Why is a Binary Search Tree (BST) preferred over a plain Binary Tree for searching operations?

easy

A. Because BST nodes can have more than two children

B. Because BST uses less memory than a plain Binary Tree

C. Because BST does not require pointers to child nodes

D. Because BST keeps elements in sorted order, allowing faster search

Solution

1. Step 1: Understand the structure difference

   A plain Binary Tree has no order, so searching requires checking many nodes.

2. Step 2: Analyze BST property

   BST keeps nodes sorted: left child smaller, right child larger, enabling binary search.

3. Final Answer:

   Because BST keeps elements in sorted order, allowing faster search -> Option D

4. Quick Check:

   Sorted structure = faster search [OK]

Hint: BST sorts nodes to speed up search [OK]

Common Mistakes:

• Thinking BST uses less memory
• Confusing number of children per node
• Assuming BST has no pointers

2. Which of the following is the correct Rust syntax to declare a node in a Binary Search Tree?

easy

A. struct Node { value: i32, left: Box<Node>, right: Box<Node> }

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

C. struct Node { value: i32, left: &Node, right: &Node }

D. struct Node { value: i32, left: Node, right: Node }

Solution

1. Step 1: Understand Rust ownership for trees

   Nodes must use Option for left and right to allow null and ownership.

2. Step 2: Check each option

   struct Node { value: i32, left: Option, right: Option } uses Option, correct for nullable child nodes. Others miss Option or use references incorrectly.

3. Final Answer:

   struct Node { value: i32, left: Option, right: Option } -> Option B

4. Quick Check:

   Nullable boxed children = struct Node { value: i32, left: Option, right: Option } [OK]

Hint: Use Option for nullable children in Rust [OK]

Common Mistakes:

• Omitting Option causing no null children
• Using references without lifetimes
• Using Box without Option causing no empty child

3. Given the following Rust code inserting values into a BST, what is the in-order traversal output?

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

fn insert(root: &mut Option, val: i32) {
    if let Some(node) = root {
        if val < node.value {
            insert(&mut node.left, val);
        } else {
            insert(&mut node.right, val);
        }
    } else {
        *root = Some(Box::new(Node { value: val, left: None, right: None }));
    }
}

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

fn main() {
    let mut root = None;
    insert(&mut root, 10);
    insert(&mut root, 5);
    insert(&mut root, 15);
    insert(&mut root, 7);
    let mut result = Vec::new();
    inorder(&root, &mut result);
    println!("{:?}", result);
}

medium

A. [5, 7, 10, 15]

B. [10, 5, 7, 15]

C. [15, 10, 7, 5]

D. [7, 5, 10, 15]

Solution

1. Step 1: Insert values into BST

   Insert 10 as root, 5 to left, 15 to right, 7 to right of 5.

2. Step 2: Perform in-order traversal

   In-order visits left, root, right: nodes visited in order 5, 7, 10, 15.

3. Final Answer:

   [5, 7, 10, 15] -> Option A

4. Quick Check:

   In-order traversal = sorted values [OK]

Hint: In-order traversal of BST gives sorted values [OK]

Common Mistakes:

• Confusing traversal order
• Inserting nodes incorrectly
• Misreading left/right child placement

4. The following Rust code attempts to insert a value into a BST but causes a compile error. What is the error?

fn insert(root: &Option, val: i32) {
    if let Some(node) = root {
        if val < node.value {
            insert(&node.left, val);
        } else {
            insert(&node.right, val);
        }
    } else {
        *root = Some(Box::new(Node { value: val, left: None, right: None }));
    }
}

medium

A. Recursive call causes stack overflow

B. Missing lifetime annotations for references

C. Cannot assign to `*root` because `root` is an immutable reference

D. Node struct is not defined

Solution

1. Step 1: Check parameter mutability

   Function takes `root` as immutable reference `&Option`, so cannot modify it.

2. Step 2: Identify assignment error

   Line `*root = Some(...)` tries to assign through immutable reference, causing compile error.

3. Final Answer:

   Cannot assign to `*root` because `root` is an immutable reference -> Option C

4. Quick Check:

   Mutable reference needed for assignment [OK]

Hint: Use &mut for parameters you want to change [OK]

Common Mistakes:

• Using & instead of &mut for mutable access
• Ignoring compiler error messages
• Assuming recursive calls cause stack overflow here

5. You want to store a large set of unique numbers and perform fast search, insert, and delete operations. Why is a BST a better choice than a plain Binary Tree, and what is the average time complexity for these operations in a balanced BST?

hard

A. BST keeps data sorted, enabling O(log n) average time for search, insert, and delete

B. BST uses less memory and has O(1) time for all operations

C. Plain Binary Tree is better because it allows faster insertions

D. BST allows multiple children per node, improving speed

Solution

1. Step 1: Compare data organization

   BST keeps nodes sorted, unlike plain Binary Tree which has no order.

2. Step 2: Analyze operation time complexity

   Balanced BST operations (search, insert, delete) take O(log n) on average due to tree height.

3. Final Answer:

   BST keeps data sorted, enabling O(log n) average time for search, insert, and delete -> Option A

4. Quick Check:

   Sorted structure + balanced height = O(log n) [OK]

Hint: Balanced BST gives O(log n) for main operations [OK]

Common Mistakes:

• Assuming O(1) time for BST operations
• Confusing plain Binary Tree with BST
• Thinking BST nodes have multiple children