Create a Binary Tree Manually in DSA Rust - Build from Scratch

Create a Binary Tree Manually

📖 Scenario: You are building a simple binary tree to organize numbers. Each node in the tree can have up to two children: a left child and a right child. This structure helps in searching and sorting numbers efficiently.

🎯 Goal: Create a binary tree manually by defining nodes and linking them as left and right children. Then print the tree nodes in a simple format to show the structure.

📋 What You'll Learn

Define a struct called Node with fields value, left, and right

Create nodes with values 10, 5, and 15

Link nodes to form a binary tree with 10 as root, 5 as left child, and 15 as right child

Print the values of the root, its left child, and its right child

💡 Why This Matters

🌍 Real World

Binary trees are used in many applications like searching, sorting, and organizing hierarchical data such as file systems or decision trees.

💼 Career

Understanding how to create and manipulate binary trees is fundamental for software engineers working with data structures, algorithms, and system design.

1

Define the Node struct and create the root node

Define a struct called Node with a field value of type i32, and two fields left and right of type Option>. Then create a variable called root which is a Node with value 10 and left and right set to None.

DSA Rust

// Define the Node struct and create the root node
// Your code here

Hint

Use Option> for left and right to allow empty children.

2

Create left and right child nodes

Create two variables called left_child and right_child which are Node structs with value 5 and 15 respectively, and both have left and right set to None.

DSA Rust

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

fn main() {
    let root = Node {
        value: 10,
        left: None,
        right: None,
    };
    // Create left and right child nodes
    // Your code here
}

Hint

Create two separate Node variables for the children with None for their children.

3

Link the child nodes to the root node

Create a new variable called root which is a Node with value 10, left set to Some(Box::new(left_child)), and right set to Some(Box::new(right_child)).

DSA Rust

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

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

    let left_child = Node {
        value: 5,
        left: None,
        right: None,
    };

    let right_child = Node {
        value: 15,
        left: None,
        right: None,
    };

    // Link children to root
    // Your code here
}

Hint

Use Some(Box::new(...)) to wrap child nodes when linking.

4

Print the values of the root and its children

Print the values of root.value, root.left.as_ref().unwrap().value, and root.right.as_ref().unwrap().value using println! statements.

DSA Rust

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

fn main() {
    let left_child = Node {
        value: 5,
        left: None,
        right: None,
    };

    let right_child = Node {
        value: 15,
        left: None,
        right: None,
    };

    let root = Node {
        value: 10,
        left: Some(Box::new(left_child)),
        right: Some(Box::new(right_child)),
    };

    // Print the values of root and its children
    // Your code here
}

Hint

Use as_ref().unwrap() to access the child nodes inside Option.

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