Create a Binary Tree Manually in DSA Javascript - Execution Trace

Concept Flow - Create a Binary Tree Manually

Create root node

↓

Assign root.left

↓

Assign root.right

↓

Repeat for each child node

↓

Tree fully built

Start by creating the root node, then assign left and right children manually for each node until the tree is complete.

Execution Sample

DSA Javascript

class Node {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = 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 assigns left and right child nodes with values 2 and 3.

Execution Table

Step	Operation	Node Created	Pointer Changes	Visual State
1	Create root node	Node(1)	root -> Node(1)	1 / \ null null
2	Assign root.left	Node(2)	root.left -> Node(2)	1 / \ 2 null / \ null null
3	Assign root.right	Node(3)	root.right -> Node(3)	1 / \ 2 3 / \ / \ null null null null
4	No more assignments	None	No pointer changes	1 / \ 2 3 / \ / \ null null null null

💡 All nodes assigned, tree creation 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 set left and right pointers to null when creating a new node?

Because initially, the new node has no children, so left and right must be null to show no links. See Step 1 in execution_table where Node(1) has null children.

What happens if we forget to assign root.left or root.right?

That child remains null, meaning no node exists there. The tree will be incomplete. See Step 2 and 3 where pointers are assigned to new nodes.

Why do we manually assign children instead of using a loop?

Because manual creation is direct and simple for small trees. Loops are used for larger or dynamic trees. This example shows basic manual linking in Steps 2 and 3.

Visual Quiz - 3 Questions

Look at the execution_table at Step 2, what is the value of root.left?

A null

B Node with value 2

C Node with value 3

D Node with value 1

💡 Hint

Check the Pointer Changes and Visual State columns at Step 2 in execution_table

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

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the Operation and Pointer Changes columns in execution_table

If we skip Step 3, what would root.right be?

A Node with value 2

B Node with value 3

C null

D Undefined

💡 Hint

Refer to variable_tracker for root.right after Step 2 and Step 3

Concept Snapshot

Create a binary tree by:
1. Creating a root node with value.
2. Manually assigning left and right children.
3. Each node's left and right start as null.
4. Repeat for all nodes to build the tree.
5. Visualize as nodes connected by left/right pointers.

Full Transcript

To create a binary tree manually, start by making a root node with a value. Each node has left and right pointers set to null initially. Then assign left and right children by creating new nodes and linking them to the parent node's left or right pointers. Repeat this process for each node you want to add. This builds the tree step-by-step. The execution table shows each step: creating the root, assigning left child, then right child, and the tree's visual state after each. Variables track the root and its children pointers. Key moments clarify why pointers start as null and what happens if assignments are missed. The quiz tests understanding of pointer assignments and tree structure at each step.