Create a Binary Tree Manually in DSA Typescript - Execution Trace

Concept Flow - Create a Binary Tree Manually

Create root node

↓

Assign root value

↓

Create left child node?

No→Done

Yes↓

Assign left child value

↓

Create right child node?

No→Back to parent

Yes↓

Assign right child value

↓

Repeat for each node as needed

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

Execution Sample

DSA Typescript

class Node {
  constructor(public val: number, public left: Node | null = null, public right: Node | null = null) {}
}

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

This code creates a root node with value 1, then manually adds left and right child nodes 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	Node(2)	root.left -> Node(2)	1 / 2
3	Assign right child	Node(3)	root.right -> Node(3)	1 / \ 2 3
4	No more nodes to add	None	No pointer changes	1 / \ 2 3

💡 All nodes manually created and assigned, 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 - 3 Insights

Why do we assign left and right children after creating the root node?

Because the root node must exist first to attach children. See execution_table steps 1 and 2 where root is created before assigning root.left.

What happens if we forget to assign a child node?

That child pointer remains null, meaning no node exists there. In the table, if root.right was not assigned, it would stay null and the tree would be incomplete.

Why do we manually create each node instead of using a loop?

Manual creation helps understand the structure clearly. Loops are used for larger trees, but here each step shows exactly how nodes connect, as in execution_table rows 2 and 3.

Visual Quiz - 3 Questions

Look at the execution_table, what is the visual state after step 2?

A 1 with right child 3 only

B 1 with both children 2 and 3

C 1 with left child 2 only

D Only root node 1

💡 Hint

Check the Visual State column in row for step 2 showing left child assigned only.

At which step is the right child node created and assigned?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the Operation and Pointer Changes columns in execution_table row 3.

If we skip step 3, what would root.right be in variable_tracker final state?

A Node(3)

B null

C Node(2)

D undefined

💡 Hint

See variable_tracker root.right value after step 2 and final if step 3 is skipped.

Concept Snapshot

Create a binary tree manually by:
- Creating the root node first
- Assigning left and right child nodes explicitly
- Each node has value, left, and right pointers
- Null means no child
- Build step-by-step for clear structure

Full Transcript

To create a binary tree manually, start by creating the root node with a value. Then assign its left and right children by creating new nodes and linking them to the root's left and right pointers. Each node holds a value and pointers to left and right children, which can be null if no child exists. This step-by-step manual creation helps visualize the tree structure clearly. The execution table shows each step with the nodes created and how pointers change, while the variable tracker shows the state of root and its children after each step. Key moments clarify why the root must be created first, what happens if children are not assigned, and why manual creation is useful for learning.