Create a Binary Tree Manually in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a binary tree?

A binary tree is a structure where each node has up to two children, called left and right. It looks like a family tree with each parent having at most two kids.

beginner

How do you create a node in a binary tree manually?

You create a node by making an object with a value and two links: one for the left child and one for the right child. Both children start as empty (None).

beginner

What does 'None' represent in a binary tree node?

'None' means there is no child node in that position. It shows the end of a branch or that the node has no left or right child.

beginner

Why do we link nodes in a binary tree?

Linking nodes connects parents to their children, making the tree structure. Without links, nodes are just separate pieces with no order or relationship.

beginner

What is the root node in a binary tree?

The root node is the top node of the tree. It has no parent and is the starting point to reach all other nodes.

What is the maximum number of children a node in a binary tree can have?

A Two

B Three

C One

D Unlimited

In a binary tree, each node can have at most two children: left and right.

What does a 'None' value in a node's child link mean?

A The node has two children

B The child node exists

C The node is the root

D The child node does not exist

'None' means there is no child node connected in that position.

Which node is the starting point of a binary tree?

A Left child

B Leaf node

C Root node

D Right child

The root node is the top node and starting point of the tree.

How do you manually create a binary tree node in Python?

A By calling a built-in binary tree function

B By creating a class with value, left, and right attributes

C By using a dictionary with keys 'value' and 'children'

D By using a list with three elements

Manually creating a node involves defining a class with value, left, and right attributes.

What is the purpose of linking nodes in a binary tree?

A To connect parents to children and form the tree structure

B To store values only

C To sort the nodes automatically

D To delete nodes easily

Linking nodes connects parents to children, creating the tree shape.

Explain how to create a simple binary tree manually with three nodes.

Think about making a parent and two children connected by links.

Describe what 'None' means in the context of binary tree nodes and why it is important.

Consider what happens when a node does not have a left or 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