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 more nodes or stop

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

Execution Sample

DSA C++

struct Node {
  int data;
  Node* left;
  Node* right;
};

Node* root = new Node{1, nullptr, nullptr};
root->left = new Node{2, nullptr, nullptr};
root->right = new Node{3, nullptr, nullptr};

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	Pointer Changes	Visual State
1	Create root node	Node(1)	root -> Node(1)	1
2	Create left child	Node(2)	root->left -> Node(2)	1 / 2
3	Create right child	Node(3)	root->right -> Node(3)	1 / \ 2 3
4	No more nodes	None	No pointer changes	1 / \ 2 3

💡 All desired nodes created, manual tree construction complete.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
root	nullptr	Node(1)	Node(1)	Node(1)	Node(1)
root->left	nullptr	nullptr	Node(2)	Node(2)	Node(2)
root->right	nullptr	nullptr	nullptr	Node(3)	Node(3)

Key Moments - 3 Insights

Why do we assign nullptr to left and right when creating a node?

Assigning nullptr means the node has no children yet. This is shown in Step 1 where root's left and right are nullptr before adding children.

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

The child pointer stays nullptr, so no child node exists there. Execution table Step 2 and 3 show pointer changes that create children.

How does the visual state represent the tree structure?

The visual state shows nodes and their connections. For example, after Step 3, '1' is root with '2' as left child and '3' as right child.

Visual Quiz - 3 Questions

Look at the execution table at Step 2, what is the value of root->left?

A Node(3)

B nullptr

C Node(2)

D Node(1)

💡 Hint

Check the 'Pointer Changes' and 'Variable Tracker' columns for Step 2.

At which step does root->right get assigned a node?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look at the 'Pointer Changes' column in the execution table.

If we skip Step 3, what would the final visual state look like?

A 1 with left child 2 only

B 1 with right child 3 only

C 1 with both children 2 and 3

D Only node 1 with no children

💡 Hint

Refer to the 'Visual State' column after Step 2 and Step 3.

Concept Snapshot

Create nodes manually by allocating memory.
Assign data and set left/right pointers to nullptr initially.
Link nodes by setting left and right pointers.
Visualize tree as root with left and right children.
Stop when all nodes are created.

Full Transcript

To create a binary tree manually, start by creating the root node with data and null children pointers. Then create left and right child nodes by allocating new nodes and linking them to the root's left and right pointers. Each node's left and right pointers start as nullptr to indicate no children. The process continues until all desired nodes are linked. The visual state shows the tree growing step-by-step with root and its children. This method builds the tree from the top down by manually assigning pointers.