Create a Binary Tree Manually in DSA Rust - Execution Trace

Concept Flow - Create a Binary Tree Manually

Create root node

↓

Assign left child to root

↓

Assign right child to root

↓

Assign children to left child

↓

Assign children to right child

↓

Tree fully built

Start by creating the root node, then assign left and right children step-by-step until the tree is complete.

Execution Sample

DSA Rust

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

let root = Node {
    value: 1,
    left: Some(Box::new(Node { value: 2, left: None, right: None })),
    right: Some(Box::new(Node { value: 3, left: None, right: None })),
};

This code creates a root node with value 1 and assigns left and right children with values 2 and 3.

Execution Table

Step	Operation	Node Created/Assigned	Pointer Changes	Visual State
1	Create root node	Node(1)	root -> Node(1)	1
2	Assign left child to root	Node(2)	root.left -> Node(2)	1 ├─ 2
3	Assign right child to root	Node(3)	root.right -> Node(3)	1 ├─ 2 └─ 3
4	Assign left child to Node(2)	Node(4)	root.left.left -> Node(4)	1 ├─ 2 │ └─ 4 └─ 3
5	Assign right child to Node(2)	Node(5)	root.left.right -> Node(5)	1 ├─ 2 │ ├─ 4 │ └─ 5 └─ 3
6	Assign left child to Node(3)	Node(6)	root.right.left -> Node(6)	1 ├─ 2 │ ├─ 4 │ └─ 5 └─ 3 └─ 6
7	Assign right child to Node(3)	Node(7)	root.right.right -> Node(7)	1 ├─ 2 │ ├─ 4 │ └─ 5 └─ 3 ├─ 6 └─ 7
8	Tree fully built	None	No pointer changes	1 ├─ 2 │ ├─ 4 │ └─ 5 └─ 3 ├─ 6 └─ 7

💡 All nodes assigned, tree construction complete

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	After 6	After 7	Final
root	None	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)	Node(1)
root.left	None	None	Node(2)	Node(2)	Node(2)	Node(2)	Node(2)	Node(2)	Node(2)
root.right	None	None	None	Node(3)	Node(3)	Node(3)	Node(3)	Node(3)	Node(3)
root.left.left	None	None	None	None	Node(4)	Node(4)	Node(4)	Node(4)	Node(4)
root.left.right	None	None	None	None	None	Node(5)	Node(5)	Node(5)	Node(5)
root.right.left	None	None	None	None	None	None	Node(6)	Node(6)	Node(6)
root.right.right	None	None	None	None	None	None	None	Node(7)	Node(7)

Key Moments - 3 Insights

Why do we use Option<Box<Node>> for left and right children?

Because children can be absent (None) or present (Some), and Box allows storing nodes on the heap to avoid recursive size issues. See execution_table steps 2 and 3 where children are assigned as Some(Box::new(Node)).

What happens if we don't assign a child node?

The child pointer remains None, meaning no child exists there. For example, before step 2, root.left is None, indicating no left child.

How does the visual state represent the tree structure?

The visual state uses indentation and lines to show parent-child relationships, e.g., step 5 shows Node(2) with children 4 and 5 indented below it.

Visual Quiz - 3 Questions

Look at the execution_table at step 4. Which node is assigned as the left child of Node(2)?

A Node(4)

B Node(5)

C Node(6)

D Node(7)

💡 Hint

Check the 'Node Created/Assigned' column at step 4 in execution_table.

At which step does root.right.right get assigned?

A Step 5

B Step 6

C Step 7

D Step 8

💡 Hint

Look at the 'Pointer Changes' column for root.right.right in execution_table.

If we skip assigning root.left.right, what will be its value after step 7?

A Node(5)

B None

C Node(4)

D Node(6)

💡 Hint

Refer to variable_tracker row for root.left.right and see what happens if no assignment occurs.

Concept Snapshot

Create a binary tree by manually creating nodes.
Each node has a value and optional left/right children.
Use Option<Box<Node>> in Rust to handle children.
Assign children step-by-step to build the tree.
Visualize tree as nodes connected by pointers.
None means no child at that position.

Full Transcript

To create a binary tree manually in Rust, start by creating the root node with a value. Then assign left and right children by creating new nodes and linking them using Option<Box<Node>>. This allows nodes to be stored on the heap and children to be optional. The process continues by assigning children to those child nodes until the tree is fully built. The visual state shows the tree structure with indentation representing parent-child relationships. Variables track the pointers to each node and their children. This step-by-step approach helps understand how a binary tree is constructed in memory.

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