Create a Binary Tree Manually in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a new binary tree node with value 10.

DSA Rust

let root = Box::new(TreeNode { val: [1], left: None, right: None });

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

A0

B10

CNone

DSome(10)

Attempts:

3 left

💡 Hint

Common Mistakes

Using None instead of an integer value.

Using Some(10) which is incorrect for val field.

The value of the node should be 10, so val: 10 is correct.

2fill in blank

medium

Complete the code to create a left child node with value 5 for the root.

DSA Rust

root.left = Some(Box::new(TreeNode { val: [1], left: None, right: None }));

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

A10

BNone

C5

DSome(5)

Attempts:

3 left

💡 Hint

Common Mistakes

Using None or Some(5) instead of just 5.

Confusing the left field with val.

The left child node value should be 5, so val: 5 is correct.

3fill in blank

hard

Fix the error in the code to create a right child node with value 15.

DSA Rust

root.right = Some([1](TreeNode { val: 15, left: None, right: None }));

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

ABox::new

BSome

CNone

Dnew

Attempts:

3 left

💡 Hint

Common Mistakes

Using Some without Box::new causes type mismatch.

Using None means no child node.

The right child must be wrapped in Box::new to allocate on heap.

4fill in blank

hard

Fill both blanks to create a root node with left and right children 7 and 20.

DSA Rust

let root = Box::new(TreeNode { val: 10, left: Some(Box::new(TreeNode { val: [1], left: None, right: None })), right: Some(Box::new(TreeNode { val: [2], left: None, right: None })) });

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

A7

B20

C15

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping left and right child values.

Using values not specified in the instruction.

Left child value is 7 and right child value is 20 as per the instruction.

5fill in blank

hard

Fill all three blanks to create a binary tree with root 8, left child 3, and right child 10.

DSA Rust

let root = Box::new(TreeNode { val: [1], left: Some(Box::new(TreeNode { val: [2], left: None, right: None })), right: Some(Box::new(TreeNode { val: [3], left: None, right: None })) });

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

A8

B3

C10

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the order of values.

Using values not matching the instruction.

Root value is 8, left child is 3, right child is 10 as required.

Practice

1. What is the main purpose of creating a binary tree manually in Rust using structs and references?

easy

A. To store data in a single linear sequence

B. To create a list of numbers in ascending order

C. To build a tree structure where each node can have up to two children

D. To perform arithmetic operations on numbers

Solution

1. Step 1: Understand binary tree structure

   A binary tree is a data structure where each node has at most two children, called left and right.

2. Step 2: Purpose of manual creation in Rust

   Manually creating a binary tree in Rust involves defining nodes and linking them with references to build this two-child structure.

3. Final Answer:

   To build a tree structure where each node can have up to two children -> Option C

4. Quick Check:

   Binary tree = nodes with up to two children [OK]

Hint: Binary tree nodes have max two children [OK]

Common Mistakes:

• Confusing binary tree with linked list
• Thinking binary tree nodes have more than two children
• Assuming binary tree stores data linearly

2. Which of the following Rust code snippets correctly defines a binary tree node struct with optional left and right children?

easy

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

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

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

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

Solution

1. Step 1: Check for optional children

   Binary tree nodes may or may not have children, so left and right should be Option types.

2. Step 2: Use Box for heap allocation

   Since nodes refer to other nodes recursively, Box is needed to allocate on heap and avoid infinite size.

3. Final Answer:

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

4. Quick Check:

   Optional boxed children = correct node struct [OK]

Hint: Use Option for children in Rust [OK]

Common Mistakes:

• Using direct Node type causing infinite size error
• Not wrapping children in Option for nullable links
• Using references without lifetimes causing errors

3. Given the following Rust code that manually creates a binary tree, what will be printed by the println! statement?

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

fn main() {
    let leaf = Node { value: 3, left: None, right: None };
    let root = Node {
        value: 1,
        left: Some(Box::new(leaf)),
        right: None,
    };
    println!("{}", root.left.as_ref().unwrap().value);
}

medium

A. 1

B. 3

C. None

D. Compilation error

Solution

1. Step 1: Understand tree structure

   The root node has value 1, with left child node value 3 and no right child.

2. Step 2: Trace the println! statement

   root.left is Some(Box<Node>) containing leaf with value 3, so unwrap().value prints 3.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   Access left child's value = 3 [OK]

Hint: Access left child with unwrap() to get value [OK]

Common Mistakes:

• Printing root value instead of left child's
• Forgetting to unwrap Option before accessing value
• Confusing left and right children

4. The following Rust code attempts to create a binary tree node but fails to compile. What is the error and how to fix it?

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

fn main() {
    let node = Node {
        value: 5,
        left: None,
        right: None,
    };
    let root = Node {
        value: 10,
        left: Some(node),
        right: None,
    };
}

medium

A. Error: cannot move `node` into `Some` because `node` does not implement Copy; fix by wrapping node in Box::new()

B. Error: missing semicolon after node declaration; fix by adding semicolon

C. Error: left field must be a reference; fix by using &node

D. No error; code compiles successfully

Solution

1. Step 1: Identify the error cause

   left field expects Option, but Some(node) tries to move Node directly, causing type mismatch.

2. Step 2: Fix by boxing node

   Wrap node in Box::new(node) inside Some to match Option type.

3. Final Answer:

   Error: cannot move `node` into `Some` because `node` does not implement Copy; fix by wrapping node in Box::new() -> Option A

4. Quick Check:

   Box node before Some to fix type error [OK]

Hint: Wrap node in Box::new() for Option [OK]

Common Mistakes:

• Trying to use node directly without Box
• Using references without lifetimes
• Ignoring compiler type mismatch errors

5. You want to manually create a binary tree in Rust with root value 10, left child 5, and right child 15. Which code snippet correctly builds this tree and prints the right child's value?

hard

A. fn main() {
struct Node {
value: i32,
left: Option,
right: Option,
}
let left = Node { value: 5, left: None, right: None };
let right = Node { value: 15, left: None, right: None };
let root = Node {
value: 10,
left: Some(left),
right: Some(right),
};
println!("{}", root.right.as_ref().unwrap().value);
}

B. fn main() {
struct Node {
value: i32,
left: Option,
right: Option,
}
let root = Node {
value: 10,
left: Some(Node { value: 5, left: None, right: None }),
right: Some(Node { value: 15, left: None, right: None }),
};
println!("{}", root.right.unwrap().value);
}

C. fn main() {
struct Node {
value: i32,
left: Option,
right: Option,
}
let root = Node {
value: 10,
left: None,
right: None,
};
println!("{}", root.right.unwrap().value);
}

D. fn main() {
struct Node {
value: i32,
left: Option,
right: Option,
}
let left = Box::new(Node { value: 5, left: None, right: None });
let right = Box::new(Node { value: 15, left: None, right: None });
let root = Node {
value: 10,
left: Some(left),
right: Some(right),
};
println!("{}", root.right.as_ref().unwrap().value);
}

Solution

1. Step 1: Check node creation and boxing

   Children must be boxed nodes wrapped in Some to match Option type.

2. Step 2: Verify printing right child's value

   Use root.right.as_ref().unwrap().value to safely access right child's value 15.

3. Final Answer:

   Code in option D correctly creates and prints right child's value 15 -> Option D

4. Quick Check:

   Box children and unwrap Option to print value [OK]

Hint: Box children nodes and unwrap Option to access value [OK]

Common Mistakes:

• Not boxing children nodes causing type errors
• Using unwrap() directly on Option without as_ref()
• Creating nodes without children or wrong types