Create a Binary Tree Manually in DSA Java - 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 other nodes or stop

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

Execution Sample

DSA Java

class Node {
  int value;
  Node left, right;
  Node(int val) { value = val; 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	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 nodes 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 - 2 Insights

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

Because each child is a separate node object created after the root; see execution_table steps 2 and 3 where left and right children are created and assigned after root.

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

The corresponding child pointer remains null, meaning no child node exists there; the tree will be incomplete as shown by the pointer changes in execution_table.

Visual Quiz - 3 Questions

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

A 1 with left child 2 only

B 1 with left child 2 and right child 3

C 1 with right child 3 only

D Only root node 1

💡 Hint

Check the Visual State column at step 2 in execution_table.

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

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the Pointer Changes column for root.right in execution_table.

If we add root.left.left = new Node(4) after step 3, how would the Visual State change?

A 1 with right child 3 only

B 1 with left child 2 and right child 3, and 2 has left child 4

C 1 with left child 2 and right child 3 only

D 1 with left child 4 only

💡 Hint

Think about adding a new node as left child of node 2, extending the tree.

Concept Snapshot

Create nodes manually by instantiating Node objects.
Assign root node first.
Assign left and right children separately.
Pointers link parent to children.
Repeat for deeper levels.
Tree grows as nodes connect.

Full Transcript

To create a binary tree manually, start by making the root node. Then create left and right child nodes and assign them to the root's left and right pointers. Each node is an object with a value and pointers to left and right children. The process repeats for each child node to build the full tree. The execution table shows each step: creating nodes and linking pointers. The variable tracker shows how root and its children pointers change after each step. Key moments clarify why children are assigned separately and what happens if pointers are not assigned. The visual quiz tests understanding of tree state at each step. This method builds the tree node by node, linking them to form the structure.

Practice

1. What is the correct way to create a root node of a binary tree manually in Java using a Node class with an integer value?

easy

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

B. Node root = Node(10);

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

D. Node root = new Node(10);

Solution

1. Step 1: Understand Node object creation

   In Java, to create an object, you use the new keyword followed by the constructor call.

2. Step 2: Apply correct syntax for constructor with value

   The constructor Node(10) creates a node with value 10. So new Node(10) is correct.

3. Final Answer:

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

4. Quick Check:

   Object creation with constructor = new Node(10) [OK]

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

Common Mistakes:

• Omitting 'new' keyword
• Using incorrect constructor syntax
• Trying to assign value without constructor

2. Which of the following is the correct syntax to manually link a left child node with value 5 to a root node in Java?

easy

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

B. root.leftNode = new Node(5);

C. root.left = Node(5);

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

Solution

1. Step 1: Understand node linking in binary tree

   The left child of a node is usually accessed by left field. Assigning a new node requires new Node(value).

2. Step 2: Apply correct field and constructor syntax

   So root.left = new Node(5); correctly creates and links the left child.

3. Final Answer:

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

4. Quick Check:

   Link left child with new Node = root.left = new Node(5) [OK]

Hint: Use 'root.left = new Node(value)' to link left child [OK]

Common Mistakes:

• Using wrong field name like leftNode
• Omitting 'new' keyword
• Incorrect constructor call without 'new'

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

class Node {
  int value;
  Node left, right;
  Node(int v) { value = v; }
}

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

void inorder(Node node) {
  if (node == null) return;
  inorder(node.left);
  System.out.print(node.value + " ");
  inorder(node.right);
}

inorder(root);

medium

A. 4 2 5 1 3

B. 1 2 3 4 5

C. 1 3 2 4 5

D. 2 4 5 1 3

Solution

1. Step 1: Understand inorder traversal order

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

2. Step 2: Trace traversal on given tree

   Left subtree of root(1) is node(2) with children 4 and 5.
   Traverse left subtree of 2: 4 (no children)
   Visit 2
   Traverse right subtree of 2: 5 (no children)
   Visit root 1
   Traverse right subtree of root: 3 (no children)
   Sequence: 4 2 5 1 3

3. Final Answer:

   4 2 5 1 3 -> Option A

4. Quick Check:

   Inorder = left, root, right = 4 2 5 1 3 [OK]

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

Common Mistakes:

• Confusing preorder or postorder with inorder
• Missing left or right subtree nodes
• Printing root before left subtree

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

class Node {
  int value;
  Node left, right;
  Node(int v) { value = v; }
}

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

medium

A. Node class constructor is missing

B. Cannot assign right child after root creation

C. Missing 'new' keyword when creating left child node

D. Value type should be String, not int

Solution

1. Step 1: Check node creation syntax

   Creating a new node requires the 'new' keyword before constructor call.

2. Step 2: Identify incorrect line

   Line root.left = Node(5); misses 'new' keyword, causing syntax error.

3. Final Answer:

   Missing 'new' keyword when creating left child node -> Option C

4. Quick Check:

   Object creation needs 'new' keyword [OK]

Hint: Always use 'new' to create objects in Java [OK]

Common Mistakes:

• Omitting 'new' keyword
• Confusing constructor call with method call
• Assuming automatic object creation

5. You want to manually create a binary tree with root value 7, left child 3, right child 9, and left child's right child 5. Which code snippet correctly builds this tree?

hard

A. Node root = new Node(7);
root.left = new Node(3);
root.right = new Node(9);
root.right.left = new Node(5);

B. Node root = new Node(7);
root.left = new Node(3);
root.right = new Node(9);
root.left.right = new Node(5);

C. Node root = new Node(7);
root.left = new Node(3);
root.left.left = new Node(9);
root.left.right = new Node(5);

D. Node root = new Node(7);
root.right = new Node(3);
root.left = new Node(9);
root.left.right = new Node(5);

Solution

1. Step 1: Create root and direct children

   Root is 7, left child 3, right child 9, so assign accordingly.

2. Step 2: Add left child's right child

   Left child's right child is 5, so root.left.right = new Node(5); is correct.

3. Final Answer:

   Node root = new Node(7); root.left = new Node(3); root.right = new Node(9); root.left.right = new Node(5); -> Option B

4. Quick Check:

   Assign children correctly by following tree structure [OK]

Hint: Assign children stepwise matching tree structure [OK]

Common Mistakes:

• Swapping left and right children
• Assigning child to wrong parent node
• Missing intermediate child nodes