Create a Binary Tree Manually in DSA C#

Mental Model

A binary tree is a structure where each node has up to two children, called left and right. Creating it manually means linking nodes by hand to form the tree.

Analogy: Think of a family tree where each person can have up to two children. You connect parents to children by drawing lines, just like linking nodes in a binary tree.

      1
     / \
    2   3
   / \
  4   5

(Each number is a node; arrows show left and right children)

Dry Run Walkthrough

Input: Create a binary tree with root 1, left child 2, right child 3, and 2's children 4 (left) and 5 (right).

Goal: Build the tree by manually linking nodes to form the structure described.

Step 1: Create root node with value 1

1 (root) -> left: null, right: null

Why: Start with the root node as the base of the tree

Step 2: Create node with value 2 and link as left child of root

1 -> left: 2, right: null
2 -> left: null, right: null

Why: Attach left child to root to build left subtree

Step 3: Create node with value 3 and link as right child of root

1 -> left: 2, right: 3
2 -> left: null, right: null
3 -> left: null, right: null

Why: Attach right child to root to complete root's children

Step 4: Create node with value 4 and link as left child of node 2

1 -> left: 2, right: 3
2 -> left: 4, right: null
3 -> left: null, right: null
4 -> left: null, right: null

Why: Build left subtree of node 2

Step 5: Create node with value 5 and link as right child of node 2

1 -> left: 2, right: 3
2 -> left: 4, right: 5
3 -> left: null, right: null
4 -> left: null, right: null
5 -> left: null, right: null

Why: Complete node 2's children to finish the tree

Result:

1
├─ left -> 2
│  ├─ left -> 4
│  └─ right -> 5
└─ right -> 3

Tree created with root 1 and children as described

Annotated Code

DSA C#

using System;

public class Node
{
    public int Value;
    public Node Left;
    public Node Right;

    public Node(int value)
    {
        Value = value;
        Left = null;
        Right = null;
    }
}

public class BinaryTree
{
    public Node Root;

    public BinaryTree()
    {
        Root = null;
    }

    public void CreateManualTree()
    {
        Root = new Node(1); // create root node
        Root.Left = new Node(2); // link left child
        Root.Right = new Node(3); // link right child
        Root.Left.Left = new Node(4); // link left child of node 2
        Root.Left.Right = new Node(5); // link right child of node 2
    }

    public void PrintTree(Node node, string indent = "", bool isLeft = true)
    {
        if (node == null) return;

        Console.WriteLine(indent + (isLeft ? "├─ left -> " : "└─ right -> ") + node.Value);
        indent += isLeft ? "│  " : "   ";

        PrintTree(node.Left, indent, true);
        PrintTree(node.Right, indent, false);
    }
}

class Program
{
    static void Main()
    {
        BinaryTree tree = new BinaryTree();
        tree.CreateManualTree();
        Console.WriteLine(tree.Root.Value);
        tree.PrintTree(tree.Root, "", true);
    }
}

Root = new Node(1); // create root node

create root node as starting point

Root.Left = new Node(2); // link left child

link left child to root

Root.Right = new Node(3); // link right child

link right child to root

Root.Left.Left = new Node(4); // link left child of node 2

link left child to node 2

Root.Left.Right = new Node(5); // link right child of node 2

link right child to node 2

Output

1

├─ left -> 2

│  ├─ left -> 4

│  └─ right -> 5

└─ right -> 3

Complexity Analysis

Time: O(1) because we manually create and link a fixed number of nodes

Space: O(n) where n is number of nodes created, as each node uses memory

vs Alternative: Manual creation is simple and direct; alternative is building from input or recursion which may be more complex but flexible

Edge Cases

Empty tree (no nodes)

Root remains null, no nodes created

DSA C#

Root = null; (in BinaryTree constructor)

Single node tree

Only root node created, no children linked

DSA C#

Root = new Node(1); // create root node

When to Use This Pattern

When you need to build a binary tree from scratch with known fixed nodes, manually linking nodes is the straightforward pattern to use.

Common Mistakes

Mistake: Forgetting to link child nodes to their parents
Fix: Always assign child nodes to the parent's Left or Right property explicitly

Mistake: Mixing up left and right child assignments
Fix: Remember left child goes to Left property, right child to Right property

Summary

Manually create and link nodes to build a binary tree structure.

Use when you know the exact tree structure and want to build it step-by-step.

The key is to create nodes and connect them by setting Left and Right pointers correctly.

Practice

1. What is the correct way to create a root node manually in a binary tree using C#?

easy

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

B. Node root = Node(10);

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

D. Node root = new Node(10);

Solution

1. Step 1: Understand Node creation syntax

   In C#, to create an object, use the 'new' keyword followed by the constructor call with parameters.

2. Step 2: Apply correct syntax for root node

   Using 'new Node(10)' correctly creates a node with value 10 assigned.

3. Final Answer:

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

4. Quick Check:

   Use 'new' keyword with constructor to create node [OK]

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

Common Mistakes:

• Omitting 'new' keyword when creating node
• Assigning value directly to node variable
• Calling constructor without 'new'

2. Which of the following is the correct syntax to assign a left child node with value 5 to a root node named root?

easy

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

B. root.left = Node(5);

C. root.left.value = 5;

D. root.left = 5;

Solution

1. Step 1: Understand child node assignment

   Left child must be assigned a new Node object, not just a value.

2. Step 2: Use correct syntax to assign left child

   Assigning 'root.left = new Node(5);' creates a new node with value 5 as left child.

3. Final Answer:

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

4. Quick Check:

   Assign new Node object to left child [OK]

Hint: Assign new Node object, not just value, to child [OK]

Common Mistakes:

• Assigning value directly instead of Node object
• Omitting 'new' keyword
• Trying to assign value to left property directly

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

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

medium

A. [10, 5, 3, 15]

B. [3, 5, 10, 15]

C. [5, 3, 10, 15]

D. [3, 10, 5, 15]

Solution

1. Step 1: Understand inorder traversal order

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

2. Step 2: Trace traversal on given tree

   Left subtree of root (10) is node 5, which has left child 3. So traversal order is 3, 5, 10, 15.

3. Final Answer:

   [3, 5, 10, 15] -> Option B

4. Quick Check:

   Inorder = left, root, right [OK]

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

Common Mistakes:

• Confusing preorder or postorder with inorder
• Missing leftmost node in traversal
• Listing nodes in insertion order

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

Node root = new Node(20);
root.left = 10;
root.right = new Node(30);

medium

A. Right child node value is incorrect

B. Missing 'new' keyword when creating root node

C. Assigning integer directly to 'left' instead of a Node object

D. Root node value should be a string, not integer

Solution

1. Step 1: Check left child assignment

   Left child must be a Node object, but code assigns integer 10 directly.

2. Step 2: Verify other parts

   Root node and right child are correctly created with 'new Node()'.

3. Final Answer:

   Assigning integer directly to 'left' instead of a Node object -> Option C

4. Quick Check:

   Child nodes must be Node objects [OK]

Hint: Child nodes must be Node objects, not raw values [OK]

Common Mistakes:

• Assigning raw values instead of Node objects
• Forgetting 'new' keyword for node creation
• Confusing node value type requirements

5. You want to manually create this binary tree:

      8
     / \
    3   10
   / \    \
  1   6    14
     / \   /
    4   7 13

Which code snippet correctly creates this tree?

hard

A. Node root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.right = new Node(14);
root.right.right.left = new Node(13);

B. Node root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(7);
root.left.right.right = new Node(4);
root.right.right = new Node(14);
root.right.right.left = new Node(13);

C. Node root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.left = new Node(14);
root.right.left.left = new Node(13);

D. Node root = new Node(8);
root.left = new Node(3);
root.right = new Node(10);
root.left.left = new Node(1);
root.left.right = new Node(6);
root.left.right.left = new Node(4);
root.left.right.right = new Node(7);
root.right.right = new Node(13);
root.right.right.left = new Node(14);

Solution

1. Step 1: Map tree structure to code

   Root 8 has left 3 and right 10. Node 3 has children 1 and 6. Node 6 has children 4 and 7. Node 10 has right child 14, which has left child 13.

2. Step 2: Verify code matches tree

   Node root = new Node(8); root.left = new Node(3); root.right = new Node(10); root.left.left = new Node(1); root.left.right = new Node(6); root.left.right.left = new Node(4); root.left.right.right = new Node(7); root.right.right = new Node(14); root.right.right.left = new Node(13); correctly assigns all nodes to their proper left or right children matching the tree diagram.

3. Final Answer:

   Option A code snippet correctly creates the tree -> Option A

4. Quick Check:

   Match tree structure exactly in code [OK]

Hint: Match each node's left/right child exactly as tree diagram [OK]

Common Mistakes:

• Swapping left and right children
• Assigning children to wrong parent nodes
• Mixing up node values in assignments