Insert into a Binary Search Tree - Practice Coding Problems

Insert into a Binary Search Tree - Problem

You are given the root node of a binary search tree (BST) and a value to insert into the tree. Your task is to insert the new value while maintaining the BST property and return the root of the modified tree.

In a BST, for every node:

All values in the left subtree are less than the node's value
All values in the right subtree are greater than the node's value

The problem guarantees that the new value does not already exist in the BST. Since there can be multiple valid insertion points that preserve the BST property, you can return any valid result.

Example: Inserting 5 into a BST with root 4 having left child 2 and right child 7 would result in 5 being placed as the left child of 7.

Input & Output

example_1.py — Basic Insertion

$ Input: root = [4,2,7,1,3], val = 5

› Output: [4,2,7,1,3,5] or [4,2,7,1,3,null,null,null,null,null,null,5]

💡 Note: The value 5 is greater than root 4, so we go right to node 7. Since 5 < 7, we go to the left child of 7 (which is null) and insert 5 there. The BST property is maintained.

example_2.py — Single Node Tree

$ Input: root = [40,20,60,10,30,50,70], val = 25

› Output: [40,20,60,10,30,50,70,null,null,25]

💡 Note: Starting at 40, 25 < 40 so go left to 20. Since 25 > 20, go right to 30. Since 25 < 30, go left to null position and insert 25 as left child of 30.

example_3.py — Empty Tree

$ Input: root = [], val = 5

› Output: [5]

💡 Note: When the tree is empty (root is null), simply create a new node with the given value and return it as the new root.

Constraints

The number of nodes in the tree will be in the range [0, 10⁴]
-10⁸ <= Node.val <= 10⁸
-10⁸ <= val <= 10⁸
It's guaranteed that val does not exist in the original BST

Visualization

Tap to expand

Understanding the Visualization

Enter Theater

Start at the main entrance (root node) with your ticket number

Follow Signs

Compare your number with the current section - go left if smaller, right if larger

Find Empty Seat

When you reach an empty spot, that's where you sit (insert the new node)

Seated

You're now part of the organized seating arrangement (BST structure maintained)

Key Takeaway

🎯 Key Insight: BST insertion is like following a treasure map - the BST property acts as directional signs that guide us straight to the insertion point without exploring unnecessary paths!

Asked in

A Amazon 45 G Google 38 ⊞ Microsoft 32 Apple 28 f Meta 25

The optimal approach uses recursive BST insertion with O(log n) time complexity. We follow the BST property: go left if the value is smaller, right if larger, until we find an empty spot. This preserves the original tree structure while efficiently inserting the new node. Both recursive and iterative implementations work well.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Inorder Traversal + Reconstruction)	O(n)	O(n)	Extract all values, add new value, sort, and rebuild BST
Recursive BST Insertion (Optimal)	O(log n)	O(log n)	Follow BST property to find insertion point recursively

Brute Force (Inorder Traversal + Reconstruction) — Algorithm Steps

Perform inorder traversal to extract all values into an array
Add the new value to the array
Sort the array (though inorder already gives sorted values)
Reconstruct a balanced BST from the sorted array
Return the root of the new BST

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Values

Perform inorder traversal to get all values in sorted order

Add New Value

Insert the new value and sort the array

Rebuild Tree

Construct a new balanced BST from the sorted array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void inorder(struct TreeNode* node, int* values, int* index) {
    if (!node) return;
    inorder(node->left, values, index);
    values[(*index)++] = node->val;
    inorder(node->right, values, index);
}

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

struct TreeNode* buildBST(int* values, int start, int end) {
    if (start > end) return NULL;
    int mid = (start + end) / 2;
    struct TreeNode* node = createNode(values[mid]);
    node->left = buildBST(values, start, mid - 1);
    node->right = buildBST(values, mid + 1, end);
    return node;
}

struct TreeNode* insertIntoBST(struct TreeNode* root, int val) {
    if (!root) return createNode(val);
    
    int values[10001]; // Assuming max 10000 nodes
    int index = 0;
    inorder(root, values, &index);
    values[index++] = val;
    qsort(values, index, sizeof(int), compare);
    
    return buildBST(values, 0, index - 1);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

O(n) for inorder traversal + O(n) for BST reconstruction = O(n) total

✓ Linear Growth

Space Complexity

O(n)

O(n) for storing all values in array + O(log n) recursion stack

⚡ Linearithmic Space

89.5K Views

High Frequency

~15 min Avg. Time

2.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Inorder Traversal + Reconstruction) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler