Create a Binary Tree Manually in DSA Java - Build from Scratch

Create a Binary Tree Manually

📖 Scenario: Imagine you want to organize your family tree on paper. Each person can have up to two children. We will create a simple family tree using a binary tree structure in Java.

🎯 Goal: You will build a binary tree manually by creating nodes and linking them as left and right children. Then, you will print the tree nodes in a simple order.

📋 What You'll Learn

Create a Node class with int data, Node left, and Node right fields

Create a root node with value 1

Add left and right children to the root node with values 2 and 3

Add children to node 2 with values 4 (left) and 5 (right)

Print the tree nodes in preorder traversal (root, left, right)

💡 Why This Matters

🌍 Real World

Binary trees are used in many places like organizing family trees, decision making, and searching data quickly.

💼 Career

Understanding how to create and traverse trees is important for software development roles involving data structures and algorithms.

1

Create the Node class and root node

Create a class called Node with an int data field and two Node fields called left and right. Then create a Node variable called root and set it to a new Node with data value 1.

DSA Java

// Define Node class and create root node with data 1
// Your code here

Hint

Think of Node as a box holding a number and two smaller boxes (left and right). Start by making the box and putting 1 inside it.

2

Add left and right children to the root

Add a left child to root with data value 2 and a right child to root with data value 3.

DSA Java

class Node {
    int data;
    Node left;
    Node right;

    Node(int data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

public class Main {
    public static void main(String[] args) {
        Node root = new Node(1);
        // Add left and right children to root
        // Your code here
    }
}

Hint

Think of the root box having two smaller boxes inside it. Put 2 in the left box and 3 in the right box.

3

Add children to the left child of root

Add a left child to root.left with data value 4 and a right child to root.left with data value 5.

DSA Java

class Node {
    int data;
    Node left;
    Node right;

    Node(int data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

public class Main {
    public static void main(String[] args) {
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        // Add children to root.left
        // Your code here
    }
}

Hint

Now the left child of root also has two boxes. Put 4 in the left and 5 in the right.

4

Print the tree nodes in preorder traversal

Write a method called preorder that takes a Node and prints its data followed by preorder traversal of its left and right children. Then call preorder(root) inside main to print the tree nodes.

DSA Java

class Node {
    int data;
    Node left;
    Node right;

    Node(int data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

public class Main {
    public static void preorder(Node node) {
        // Your code here
    }

    public static void main(String[] args) {
        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);
        // Call preorder traversal here
        // Your code here
    }
}

Hint

Print the current node's data first, then visit left child, then right child. Call this method starting from root.

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