Create a Binary Tree Manually in DSA C# - Execution Trace

Concept Flow - Create a Binary Tree Manually

Create root node

↓

Assign root value

↓

Create left child node

↓

Assign left child value

↓

Create right child node

↓

Assign right child value

↓

Repeat for each child as needed

↓

Binary tree constructed

Start by creating the root node, then create and assign left and right child nodes step-by-step until the tree is built.

Execution Sample

DSA C#

class Node {
  public int val;
  public Node left, right;
  public Node(int v) { val = v; left = right = null; }
}

Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);

This code creates a binary tree with root value 1, left child 2, and right child 3.

Execution Table

Step	Operation	Node Created/Assigned	Pointer Changes	Visual State
1	Create root node	Node(1)	root -> Node(1)	1
2	Create left child node	Node(2)	root.left -> Node(2)	1 / 2
3	Create right child node	Node(3)	root.right -> Node(3)	1 / \ 2 3
4	No more nodes to add	None	None	1 / \ 2 3

💡 All nodes created and assigned, binary tree construction complete.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
root	null	Node(1)	Node(1)	Node(1)	Node(1)
root.left	null	null	Node(2)	Node(2)	Node(2)
root.right	null	null	null	Node(3)	Node(3)

Key Moments - 2 Insights

Why do we assign root.left and root.right separately instead of during root creation?

Because each child node is created as a separate object after the root node exists, as shown in steps 2 and 3 in the execution_table.

What does the visual state '1\n / \ 2 3' represent?

It shows the tree structure with root node 1, left child 2, and right child 3, matching the pointer assignments in steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution_table at step 2, what pointer is changed?

A root.right

B root.left

C root

D root.left.left

💡 Hint

Check the 'Pointer Changes' column at step 2 in execution_table.

At which step does the binary tree first have both left and right children assigned?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Pointer Changes' and 'Visual State' columns in execution_table.

If we add a left child to node 2, which variable would change next?

A root.left.left

B root.right.left

C root.left.right

D root.right.right

💡 Hint

Think about the left child of the left child of root, check variable_tracker for similar patterns.

Concept Snapshot

Create a binary tree by:
1. Creating the root node.
2. Assigning left and right child nodes separately.
3. Each node stores a value and pointers to left and right children.
4. Repeat for deeper levels as needed.
5. Visualize tree as root with branches to children.

Full Transcript

To create a binary tree manually, start by creating the root node with a value. Then create left and right child nodes as separate objects and assign them to the root's left and right pointers. This process continues for each node where children are needed. The code example shows creating a root node with value 1, then assigning left child 2 and right child 3. The execution table traces each step, showing node creation and pointer assignments, with the visual state illustrating the tree structure. Variables track the root and its children pointers. Key moments clarify why children are assigned separately and how the visual state represents the tree. The quiz tests understanding of pointer changes and tree structure growth.

Practice

1. What is the correct way to create a root node manually in a binary tree using C#?

easy

A. Node root = new Node(); root = 10;

B. Node root = Node(10);

C. Node root = new Node(); root.value = 10;

D. Node root = new Node(10);

Solution

1. Step 1: Understand Node creation syntax

   In C#, to create an object, use the 'new' keyword followed by the constructor call with parameters.

2. Step 2: Apply correct syntax for root node

   Using 'new Node(10)' correctly creates a node with value 10 assigned.

3. Final Answer:

   Node root = new Node(10); -> Option D

4. Quick Check:

   Use 'new' keyword with constructor to create node [OK]

Hint: Use 'new' keyword with constructor to create nodes [OK]

Common Mistakes:

• Omitting 'new' keyword when creating node
• Assigning value directly to node variable
• Calling constructor without 'new'

2. Which of the following is the correct syntax to assign a left child node with value 5 to a root node named root?

easy

A. root.left = new Node(5);

B. root.left = Node(5);

C. root.left.value = 5;

D. root.left = 5;

Solution

1. Step 1: Understand child node assignment

   Left child must be assigned a new Node object, not just a value.

2. Step 2: Use correct syntax to assign left child

   Assigning 'root.left = new Node(5);' creates a new node with value 5 as left child.

3. Final Answer:

   root.left = new Node(5); -> Option A

4. Quick Check:

   Assign new Node object to left child [OK]

Hint: Assign new Node object, not just value, to child [OK]

Common Mistakes:

• Assigning value directly instead of Node object
• Omitting 'new' keyword
• Trying to assign value to left property directly

3. Given the following code, what is the output of an inorder traversal (left, root, right)?

Node root = new Node(10);
root.left = new Node(5);
root.right = new Node(15);
root.left.left = new Node(3);

medium

A. [10, 5, 3, 15]

B. [3, 5, 10, 15]

C. [5, 3, 10, 15]

D. [3, 10, 5, 15]

Solution

1. Step 1: Understand inorder traversal order

   Inorder visits left subtree, then root, then right subtree.

2. Step 2: Trace traversal on given tree

   Left subtree of root (10) is node 5, which has left child 3. So traversal order is 3, 5, 10, 15.

3. Final Answer:

   [3, 5, 10, 15] -> Option B

4. Quick Check:

   Inorder = left, root, right [OK]

Hint: Inorder = left subtree, root, then right subtree [OK]

Common Mistakes:

• Confusing preorder or postorder with inorder
• Missing leftmost node in traversal
• Listing nodes in insertion order

4. Identify the error in the following code that tries to create a binary tree:

Node root = new Node(20);
root.left = 10;
root.right = new Node(30);

medium

A. Right child node value is incorrect

B. Missing 'new' keyword when creating root node

C. Assigning integer directly to 'left' instead of a Node object

D. Root node value should be a string, not integer

Solution

1. Step 1: Check left child assignment

   Left child must be a Node object, but code assigns integer 10 directly.

2. Step 2: Verify other parts

   Root node and right child are correctly created with 'new Node()'.

3. Final Answer:

   Assigning integer directly to 'left' instead of a Node object -> Option C

4. Quick Check:

   Child nodes must be Node objects [OK]

Hint: Child nodes must be Node objects, not raw values [OK]

Common Mistakes:

• Assigning raw values instead of Node objects
• Forgetting 'new' keyword for node creation
• Confusing node value type requirements

5. You want to manually create this binary tree:

      8
     / \
    3   10
   / \    \
  1   6    14
     / \   /
    4   7 13

Which code snippet correctly creates this tree?

hard

A. Node root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.right = new Node(14);
root.right.right.left = new Node(13);

B. Node root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(7);
root.left.right.right = new Node(4);
root.right.right = new Node(14);
root.right.right.left = new Node(13);

C. Node root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.left = new Node(14);
root.right.left.left = new Node(13);

D. Node root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.right = new Node(13);
root.right.right.left = new Node(14);

Solution

1. Step 1: Map tree structure to code

   Root 8 has left 3 and right 10. Node 3 has children 1 and 6. Node 6 has children 4 and 7. Node 10 has right child 14, which has left child 13.

2. Step 2: Verify code matches tree

   Node root = new Node(8); root.left = new Node(3); root.right = new Node(10); root.left.left = new Node(1); root.left.right = new Node(6); root.left.right.left = new Node(4); root.left.right.right = new Node(7); root.right.right = new Node(14); root.right.right.left = new Node(13); correctly assigns all nodes to their proper left or right children matching the tree diagram.

3. Final Answer:

   Option A code snippet correctly creates the tree -> Option A

4. Quick Check:

   Match tree structure exactly in code [OK]

Hint: Match each node's left/right child exactly as tree diagram [OK]

Common Mistakes:

• Swapping left and right children
• Assigning children to wrong parent nodes
• Mixing up node values in assignments