Insertion in BST in Data Structures Theory - Mini Project: Build & Apply

Insertion in BST

📖 Scenario: You are learning how to insert numbers into a Binary Search Tree (BST). A BST is a way to organize numbers so that smaller numbers go to the left and larger numbers go to the right. This helps find numbers quickly later.

🎯 Goal: Build a simple BST by inserting numbers one by one, following the BST rules.

📋 What You'll Learn

Create a node class with value, left, and right

Create a BST class with an insert method

Insert given numbers into the BST following BST rules

Show the final tree structure in code

💡 Why This Matters

🌍 Real World

BSTs are used in databases and search engines to organize data for fast searching and sorting.

💼 Career

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

1

Create the Node class

Create a class called Node with an __init__ method that takes a parameter value. Inside, set self.value = value, self.left = None, and self.right = None.

Data Structures Theory

# Create the Node class with __init__ method
# Your code here

Hint

Think of a node as a box holding a number and two empty spots for smaller and larger numbers.

2

Create the BST class with root

Create a class called BST with an __init__ method that sets self.root = None.

Data Structures Theory

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

# Create the BST class with root set to None
# Your code here

Hint

The BST starts empty, so the root is None at first.

3

Add the insert method to BST

Inside the BST class, create a method called insert that takes self and value. If self.root is None, set it to a new Node with value. Otherwise, call a helper method _insert_recursive with self.root and value.

Data Structures Theory

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 to BST
# Your code here

Hint

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

4

Implement the _insert_recursive helper method

Inside the BST class, create a method called _insert_recursive that takes self, current_node, and value. If value is less than current_node.value, check if current_node.left is None. If yes, set it to a new Node with value. Otherwise, call _insert_recursive on current_node.left and value. If value is greater or equal, do the same on the right side.

Data Structures Theory

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 to BST
# Your code here

Hint

Compare the new value with the current node's value to decide left or right. Insert if empty, else go deeper.

Practice

1. What happens when you insert a new value smaller than the current node in a Binary Search Tree (BST)?

easy

A. The new value replaces the current node.

B. The new value is inserted in the right subtree of the current node.

C. The new value is inserted in the left subtree of the current node.

D. The new value is ignored.

Solution

1. Step 1: Understand BST insertion rule for smaller values

   In a BST, if the new value is smaller than the current node, it must go to the left subtree.

2. Step 2: Apply the rule to the insertion process

   The new value is inserted into the left subtree, maintaining BST order.

3. Final Answer:

   The new value is inserted in the left subtree of the current node. -> Option C

4. Quick Check:

   Smaller value goes left [OK]

Hint: Smaller values always go to the left subtree [OK]

Common Mistakes:

• Inserting smaller values to the right subtree
• Replacing the current node instead of inserting
• Ignoring the new value

2. Which of the following is the correct way to insert a value into an empty Binary Search Tree (BST)?

easy

A. Set the new value as the root node of the BST.

B. Insert the new value as the left child of a random node.

C. Ignore the new value since the tree is empty.

D. Insert the new value as the right child of a random node.

Solution

1. Step 1: Identify insertion behavior for an empty BST

   When the BST is empty, the first inserted value becomes the root node.

2. Step 2: Confirm the correct insertion method

   Setting the new value as the root node initializes the BST correctly.

3. Final Answer:

   Set the new value as the root node of the BST. -> Option A

4. Quick Check:

   Empty tree insertion sets root [OK]

Hint: First insertion always becomes the root node [OK]

Common Mistakes:

• Trying to insert as child without a root
• Ignoring insertion in empty tree
• Inserting randomly without root

3. Consider the BST below:

    10
   /  
  5   15

What will the BST look like after inserting the value 12?

medium

A. 10
/
5 15
/
12

B. 10
/
5 12

15

C. 10
/
5 15

12

D. 10
/
5 12
/
15

Solution

1. Step 1: Compare 12 with root and right child

   12 is greater than 10, so move to right subtree. 12 is less than 15, so it goes to the left of 15.

2. Step 2: Insert 12 as left child of 15

   Place 12 as the left child of node 15 to maintain BST order.

3. Final Answer:

   12 is inserted as left child of 15. -> Option A

4. Quick Check:

   12 > 10 and 12 < 15, so left of 15 [OK]

Hint: Compare stepwise: left if smaller, right if larger [OK]

Common Mistakes:

• Inserting 12 as right child of 15
• Inserting 12 as right child of 10
• Ignoring BST order rules

4. Identify the error in the following BST insertion pseudocode:

function insert(node, value):
  if node is null:
    return new Node(value)
  if value > node.value:
    node.left = insert(node.left, value)
  else:
    node.right = insert(node.right, value)
  return node

medium

A. The code inserts smaller values to the left subtree instead of right.

B. The code does not handle the base case for empty tree.

C. The code incorrectly returns null instead of the node.

D. The code inserts larger values to the left subtree instead of right.

Solution

1. Step 1: Analyze insertion direction for larger values

   The code inserts values greater than current node into the left subtree, which is incorrect.

2. Step 2: Correct insertion direction for BST

   Larger values should be inserted into the right subtree to maintain BST order.

3. Final Answer:

   The code inserts larger values to the left subtree instead of right. -> Option D

4. Quick Check:

   Larger values go right, not left [OK]

Hint: Larger values always go right subtree [OK]

Common Mistakes:

• Swapping left and right insertion conditions
• Missing base case for null node
• Returning wrong node after insertion

5. You have a BST with values 20, 10, 30, 25, and 40 inserted in that order. Now you want to insert 30 again. Where should the new 30 be inserted according to standard BST insertion rules?

hard

A. As the left child of the existing 30 node.

B. As the right child of the existing 30 node.

C. Replace the existing 30 node with the new 30.

D. Do not insert duplicates in BST.

Solution

1. Step 1: Understand BST insertion for equal values

   Standard BST insertion places values equal to the current node in the right subtree.

2. Step 2: Insert new 30 as right child of existing 30

   The new 30 should be inserted as the right child of the existing 30 node.

3. Final Answer:

   As the right child of the existing 30 node. -> Option B

4. Quick Check:

   Equal values go right subtree [OK]

Hint: Equal values go to right subtree in BST [OK]

Common Mistakes:

• Inserting duplicates to the left subtree
• Replacing existing nodes instead of inserting
• Ignoring duplicates insertion rules