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

Create a Binary Tree Manually

📖 Scenario: You are building a simple binary tree to represent a family tree. Each node will hold a person's name. You will create the tree manually by linking nodes together.

🎯 Goal: Build a binary tree manually by creating nodes and linking them as left and right children. Then print the tree nodes in a simple format.

📋 What You'll Learn

Create a class called Node with attributes name, left, and right

Create nodes for "Grandparent", "Parent1", "Parent2", "Child1", and "Child2"

Link the nodes to form a binary tree with Grandparent as root

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

💡 Why This Matters

🌍 Real World

Binary trees are used in many areas like organizing family trees, file systems, and decision-making processes.

💼 Career

Understanding how to create and traverse trees is fundamental for software developers working with data structures, databases, and algorithms.

1

Create the Node class

Create a class called Node with an __init__ method that takes name as a parameter and sets self.name, self.left, and self.right to None.

DSA Python

# Your code here

Hint

Think of Node as a box that holds a name and has two empty slots for children.

2

Create nodes for family members

Create five variables: grandparent, parent1, parent2, child1, and child2. Assign each a Node object with names "Grandparent", "Parent1", "Parent2", "Child1", and "Child2" respectively.

DSA Python

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

# Your code here

Hint

Use the Node class to create each family member as a node.

3

Link the nodes to form the binary tree

Link the nodes by setting grandparent.left to parent1 and grandparent.right to parent2. Then set parent1.left to child1 and parent1.right to child2.

DSA Python

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

grandparent = Node("Grandparent")
parent1 = Node("Parent1")
parent2 = Node("Parent2")
child1 = Node("Child1")
child2 = Node("Child2")

# Your code here

Hint

Think of left and right as branches connecting family members.

4

Print the tree nodes in preorder traversal

Define a function called preorder that takes a node parameter. It should print node.name, then recursively call itself on node.left and node.right if they exist. Then call preorder(grandparent) to print the tree.

DSA Python

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

grandparent = Node("Grandparent")
parent1 = Node("Parent1")
parent2 = Node("Parent2")
child1 = Node("Child1")
child2 = Node("Child2")

grandparent.left = parent1
grandparent.right = parent2
parent1.left = child1
parent1.right = child2

# Your code here

Hint

Preorder means visit the current node first, then left child, then right child.

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