BST Insert Operation in DSA Python - Build from Scratch

BST Insert Operation

📖 Scenario: You are building a simple phone book app that stores phone numbers in a Binary Search Tree (BST) to keep them sorted for quick search and insertion.

🎯 Goal: Build a BST by inserting phone numbers one by one and then print the tree in sorted order.

📋 What You'll Learn

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

Create a class called BST with a root attribute initialized to None

Add an insert method in BST to insert a new number correctly

Add an inorder method in BST to print the tree values in sorted order

💡 Why This Matters

🌍 Real World

Binary Search Trees are used in databases and file systems to keep data sorted and allow fast search, insert, and delete operations.

💼 Career

Understanding BST insertions is important for software engineers working with data structures, algorithms, and performance optimization.

1

Create Node and BST classes

Create a class called Node with an __init__ method that takes value and sets left and right to None. Then create a class called BST with an __init__ method that sets root to None.

DSA Python

# Your code here

Hint

Think of Node as a box holding a number and two empty spaces for smaller and bigger numbers.

2

Add insert method to BST

Add a method called insert in BST that takes a value. If root is None, set root to a new Node with value. Otherwise, call a helper method _insert_recursive with root and value.

DSA Python

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

class BST:
    def __init__(self):
        self.root = None

# Add insert method here
# Your code here

Hint

Start by checking if the tree is empty. If yes, the new number becomes the root.

3

Implement _insert_recursive helper method

Add a private method called _insert_recursive in BST that takes current_node and value. If value is less than current_node.value, insert to the left subtree; if left child is None, create new Node, else recurse left. If value is greater or equal, do the same on the right subtree.

DSA Python

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

class BST:
    def __init__(self):
        self.root = None

    def insert(self, value):
        if self.root is None:
            self.root = Node(value)
        else:
            self._insert_recursive(self.root, value)

# Add _insert_recursive method here
# Your code here

Hint

Compare the new number with current node. Go left if smaller, right if bigger or equal. Insert when you find an empty spot.

4

Add inorder traversal and print the BST

Add a method called inorder in BST that prints all values in sorted order by traversing left subtree, printing current node value, then right subtree. Use a helper method _inorder_recursive that takes a node. Then create a BST instance, insert values 50, 30, 70, 20, 40, 60, 80, and call inorder to print the sorted numbers separated by spaces.

DSA Python

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

class BST:
    def __init__(self):
        self.root = None

    def insert(self, value):
        if self.root is None:
            self.root = Node(value)
        else:
            self._insert_recursive(self.root, value)

    def _insert_recursive(self, current_node, value):
        if value < current_node.value:
            if current_node.left is None:
                current_node.left = Node(value)
            else:
                self._insert_recursive(current_node.left, value)
        else:
            if current_node.right is None:
                current_node.right = Node(value)
            else:
                self._insert_recursive(current_node.right, value)

# Add inorder and _inorder_recursive methods here
# Then create BST instance, insert values, and print inorder
# Your code here

Hint

Inorder traversal visits left child, then current node, then right child. This prints numbers sorted.

Practice

1. What is the main purpose of the insert operation in a Binary Search Tree (BST)?

easy

A. To balance the BST automatically

B. To add a new value while keeping the BST property intact

C. To find the maximum value in the BST

D. To delete a node from the BST

Solution

1. Step 1: Understand the BST property

   A BST keeps values in order: left child smaller, right child larger.

2. Step 2: Purpose of insert operation

   Insert adds a new value so the tree remains ordered by BST rules.

3. Final Answer:

   To add a new value while keeping the BST property intact -> Option B

4. Quick Check:

   Insert = Add value maintaining order [OK]

Hint: Insert means add value keeping order [OK]

Common Mistakes:

• Confusing insert with delete
• Thinking insert balances the tree automatically
• Believing insert finds max value

2. Which of the following is the correct Python function signature for inserting a value into a BST node?

easy

A. def insert(root, value):

B. def insert(value, root):

C. def insert(value):

D. def insert(root):

Solution

1. Step 1: Identify parameters needed for insertion

   We need the root node to start and the value to insert.

2. Step 2: Check function signature correctness

   Signature with root first, then value is common and clear: def insert(root, value):.

3. Final Answer:

   def insert(root, value): -> Option A

4. Quick Check:

   Insert(root, value) signature [OK]

Hint: Insert needs root node and value [OK]

Common Mistakes:

• Swapping parameter order
• Missing root parameter
• Using only one parameter

3. What will be the output of the BST after inserting 7 into the BST shown below?

Initial BST (inorder): 3 -> 5 -> 8 -> 10 -> null

Code snippet:

root = BSTNode(5)
root.left = BSTNode(3)
root.right = BSTNode(8)
root.right.right = BSTNode(10)
root = insert(root, 7)
print_inorder(root)

medium

A. 3 -> 5 -> 7 -> 8 -> 10 -> null

B. 3 -> 5 -> 8 -> 7 -> 10 -> null

C. 3 -> 5 -> 8 -> 10 -> 7 -> null

D. 3 -> 5 -> 7 -> 10 -> 8 -> null

Solution

1. Step 1: Locate correct position for 7 in BST

   7 is greater than 5, so go right to 8. 7 is less than 8, so insert as left child of 8.

2. Step 2: Perform inorder traversal after insertion

   Inorder visits left, root, right: 3, 5, 7, 8, 10.

3. Final Answer:

   3 -> 5 -> 7 -> 8 -> 10 -> null -> Option A

4. Quick Check:

   Inorder after insert 7 = 3,5,7,8,10 [OK]

Hint: Insert left if smaller, right if bigger [OK]

Common Mistakes:

• Inserting 7 as right child of 8
• Not updating tree links correctly
• Confusing inorder output order

4. Consider this buggy insert function for BST:

def insert(root, val):
    if root is None:
        return BSTNode(val)
    if val < root.val:
        insert(root.left, val)
    else:
        insert(root.right, val)
    return root

What is the main problem with this code?

medium

A. It uses wrong comparison operators

B. It does not return the new root node

C. It inserts duplicates incorrectly

D. It does not assign the recursive insert result to child nodes

Solution

1. Step 1: Check recursive calls and assignments

   The recursive calls to insert do not assign the returned node back to root.left or root.right.

2. Step 2: Understand why assignment is needed

   Without assignment, new nodes are created but not linked to the tree, so insertion fails.

3. Final Answer:

   It does not assign the recursive insert result to child nodes -> Option D

4. Quick Check:

   Assign recursive insert to children [OK]

Hint: Always assign recursive insert result to child [OK]

Common Mistakes:

• Ignoring return value of recursive insert
• Assuming insert auto-links nodes
• Confusing comparison operators

5. You have a BST with nodes: 15, 10, 20, 8, 12, 17, 25. You want to insert 19. After insertion, what is the inorder traversal of the BST?

hard

A. 8 -> 10 -> 12 -> 15 -> 19 -> 17 -> 20 -> 25 -> null

B. 8 -> 10 -> 12 -> 15 -> 17 -> 20 -> 19 -> 25 -> null

C. 8 -> 10 -> 12 -> 15 -> 17 -> 19 -> 20 -> 25 -> null

D. 8 -> 10 -> 12 -> 15 -> 17 -> 20 -> 25 -> 19 -> null

Solution

1. Step 1: Find correct position for 19 in BST

   Start at root 15: 19 > 15, go right to 20. 19 < 20, go left to 17. 19 > 17, insert as right child of 17.

2. Step 2: Perform inorder traversal after insertion

   Inorder visits nodes in ascending order: 8, 10, 12, 15, 17, 19, 20, 25.

3. Final Answer:

   8 -> 10 -> 12 -> 15 -> 17 -> 19 -> 20 -> 25 -> null -> Option C

4. Quick Check:

   Inorder after insert 19 = sorted nodes [OK]

Hint: Insert by comparing down tree, then inorder print [OK]

Common Mistakes:

• Inserting 19 as left child of 20 without checking 17
• Misordering nodes in inorder traversal
• Confusing left and right child positions