Create a Binary Tree Manually in DSA Python

Mental Model

A binary tree is a structure where each item has up to two children, like a family tree with parents and children.

Analogy: Imagine a family tree where each person can have up to two children, and you build it by connecting each child to their parent manually.

    1
   / \
  2   3
 / \
4   5

Dry Run Walkthrough

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

Goal: Build the tree structure by linking nodes manually to form the shape shown

Step 1: Create root node with value 1

1 -> 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 1

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

Why: Add left child to root to build left subtree

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

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

Why: Add right child to root to build right subtree

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

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

Why: Add left child to node 2 to extend left subtree

Step 5: Create node with value 5 and link as right child of 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: Add right child to node 2 to complete left subtree

Result:

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

Annotated Code

DSA Python

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def create_manual_tree():
    root = Node(1)  # create root node
    root.left = Node(2)  # link left child
    root.right = Node(3)  # link right child
    root.left.left = Node(4)  # left child of node 2
    root.left.right = Node(5)  # right child of node 2
    return root

def print_tree(node):
    if node is None:
        return "null"
    left = print_tree(node.left)
    right = print_tree(node.right)
    return f"{node.value} -> (L:{left}, R:{right})"

root = create_manual_tree()
print(print_tree(root))

root = Node(1) # create root node

create the root node as the starting point

root.left = Node(2) # link left child

attach left child to root

root.right = Node(3) # link right child

attach right child to root

root.left.left = Node(4) # left child of node 2

attach left child to node 2

root.left.right = Node(5) # right child of node 2

attach right child to node 2

Output

1 -> (L:2 -> (L:4 -> (L:null, R:null), R:5 -> (L:null, R:null)), R:3 -> (L:null, R:null))

Complexity Analysis

Time: O(1) because we create a fixed number of nodes manually without traversal

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

vs Alternative: Compared to building a tree from a list or input, manual creation is simpler but less flexible

Edge Cases

Empty tree (no nodes)

The root is None and no nodes exist

DSA Python

N/A - manual creation assumes at least root node

Single node tree

Only root node exists with no children

DSA Python

root = Node(1)  # create root node

When to Use This Pattern

When you need to build a tree from scratch with known fixed nodes, manually linking nodes is the simplest approach.

Common Mistakes

Mistake: Forgetting to link child nodes to their parents
Fix: Always assign child nodes to the parent's left or right attribute explicitly

Summary

It builds a binary tree by creating nodes and linking them manually.

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

The key is to create each node and connect it to its parent's left or right pointer.

Practice

1. What is the correct way to create a root node manually in a binary tree using a simple class with attributes data, left, and right?

easy

A. root = Node(10) # creates root with data 10 and no children

B. root = Node() # creates root with no data

C. root = Node.left(10) # creates left child with data 10

D. root = Node.right(10) # creates right child with data 10

Solution

1. Step 1: Understand Node class constructor

   The Node class constructor takes data as an argument and initializes left and right children as None.

2. Step 2: Create root node with data

   Using root = Node(10) creates a root node with data 10 and no children.

3. Final Answer:

   root = Node(10) # creates root with data 10 and no children -> Option A

4. Quick Check:

   Create root node with data = root = Node(10) [OK]

Hint: Use Node(data) to create a node with data and empty children [OK]

Common Mistakes:

• Trying to create children directly without root
• Calling left or right as methods
• Creating node without data when constructor requires it

2. Which of the following code snippets correctly assigns a left child node with data 5 to an existing root node named root?

easy

A. root.left = 5

B. root.left(5)

C. root.left.data = 5

D. root.left = Node(5)

Solution

1. Step 1: Assign a new Node object to root.left

   To add a left child, assign a new Node instance with data 5 to root.left.

2. Step 2: Check syntax correctness

   root.left = Node(5) correctly creates and assigns the left child node.

3. Final Answer:

   root.left = Node(5) -> Option D

4. Quick Check:

   Assign left child node = root.left = Node(5) [OK]

Hint: Assign Node(data) to left or right attribute to add child [OK]

Common Mistakes:

• Calling left as a function instead of assigning
• Assigning data directly without creating Node
• Assigning integer directly to left attribute

3. Given the following code, what is the printed output representing the tree structure?

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

def print_tree(node):
    if node is None:
        return "null"
    left_str = print_tree(node.left)
    right_str = print_tree(node.right)
    return f"{node.data} -> {left_str} -> {right_str}"

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
print(print_tree(root))

medium

A. 1 -> 2 -> 4 -> null -> null -> 3 -> null -> null

B. 1 -> 2 -> 4 -> null -> null -> null -> 3 -> null -> null

C. 1 -> 2 -> null -> 4 -> null -> null -> 3 -> null -> null

D. 1 -> 2 -> 4 -> null -> null -> null -> 3 -> null

Solution

1. Step 1: Trace print_tree calls recursively

   Starting at root (1), print left subtree (2) then right subtree (3). Node 2 has left child 4 and no right child. Node 4 has no children.

2. Step 2: Build output string step-by-step

   Node 4 returns "4 -> null -> null". Node 2 returns "2 -> 4 -> null -> null -> null". Node 3 returns "3 -> null -> null". Root returns "1 -> 2 -> 4 -> null -> null -> null -> 3 -> null -> null".

3. Final Answer:

   1 -> 2 -> 4 -> null -> null -> null -> 3 -> null -> null -> Option B

4. Quick Check:

   Recursive print_tree output = 1 -> 2 -> 4 -> null -> null -> null -> 3 -> null -> null [OK]

Hint: Trace recursion left-right-null to build output string [OK]

Common Mistakes:

• Missing null for empty children
• Confusing order of left and right
• Skipping nodes with no children

4. The following code attempts to create a binary tree but throws an error. What is the error and how to fix it?

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

root = Node(10)
root.left = Node(5)
root.right = Node(15)
root.left.left = 3  # Error here

medium

A. root.left.left should be root.left.right

B. Missing parentheses when creating Node for left child

C. Assigning integer 3 directly to left child instead of Node object

D. Node class missing __str__ method

Solution

1. Step 1: Identify the error in assignment

   Assigning 3 directly to root.left.left is wrong because it expects a Node object, not an integer.

2. Step 2: Fix by creating a Node object for left child

   Replace root.left.left = 3 with root.left.left = Node(3) to create a proper child node.

3. Final Answer:

   Assigning integer 3 directly to left child instead of Node object -> Option C

4. Quick Check:

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

Hint: Always assign Node(data) to left/right, not raw values [OK]

Common Mistakes:

• Assigning raw data instead of Node instance
• Confusing left and right child assignments
• Ignoring error messages about attribute access

5. You want to manually create this binary tree:

      10
     /  \
    5    15
     \     \
      7     20

Which code snippet correctly creates this tree?

hard

A. root = Node(10)
root.left = Node(5)
root.right = Node(15)
root.left.right = Node(7)
root.right.right = Node(20)

B. root = Node(10)
root.left = Node(5)
root.right = Node(15)
root.left.left = Node(7)
root.right.left = Node(20)

C. root = Node(10)
root.left = Node(7)
root.right = Node(5)
root.left.right = Node(20)
root.right.right = Node(15)

D. root = Node(10)
root.left = Node(5)
root.right = Node(15)
root.left.right = Node(20)
root.right.right = Node(7)

Solution

1. Step 1: Create root and immediate children

   Root is 10, left child 5, right child 15.

2. Step 2: Add right child 7 to left node and right child 20 to right node

   Node 5 has right child 7, node 15 has right child 20.

3. Step 3: Verify tree matches diagram

   root = Node(10) root.left = Node(5) root.right = Node(15) root.left.right = Node(7) root.right.right = Node(20) matches the structure exactly with correct child assignments.

4. Final Answer:

   Code in Option A correctly creates the tree -> Option A

5. Quick Check:

   Assign children as per diagram: left.right=7, right.right=20 [OK]

Hint: Match tree diagram child positions carefully when assigning nodes [OK]

Common Mistakes:

• Assigning children to wrong side (left vs right)
• Swapping node data values
• Missing intermediate child nodes